text:
//   Copyright 2011 Microsoft Corporation
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.

namespace Microsoft.Data.OData
{
    #region Namespaces
    using System;
    using System.Diagnostics;
    using System.Diagnostics.CodeAnalysis;
    using System.IO;
    using System.Text;
    using System.Xml;
#if ODATALIB_ASYNC
    using System.Threading.Tasks;
#endif
    using Microsoft.Data.Edm;
    using Microsoft.Data.Edm.Csdl;
    using Microsoft.Data.Edm.Library;
    using Microsoft.Data.OData.Atom;
    using Microsoft.Data.OData.Metadata;
    using Microsoft.Data.OData.Json;
    #endregion Namespaces

    ///
    /// Writer class used to write all OData payloads (entries, feeds, metadata documents, service documents, etc.).
    ///
    public sealed class ODataMessageWriter : IDisposable
    {
        /// The message for which the message writer was created.
        private readonly ODataMessage message;

        /// A flag indicating whether we are writing a request or a response message.
        private readonly bool writingResponse;

        /// The message writer settings to use when writing the message payload.
        private readonly ODataMessageWriterSettings settings;

        /// The model. Non-null if we do have metadata available.
        private readonly IEdmModel model;

        /// The optional URL resolver to perform custom URL resolution for URLs written to the payload.
        private readonly IODataUrlResolver urlResolver;

        /// Flag to ensure that only a single write method is called on the message writer.
        private bool writeMethodCalled;

        /// True if Dispose() has been called on this message writer, False otherwise.
        private bool isDisposed;

        /// The output context we're using to write the payload.
        /// <remarks>This is null until the first write operation is called.</remarks>
        private ODataOutputContext outputContext;

        /// The payload kind of the payload to be written with this writer.
        /// <remarks>This is either set via the SetHeadersForPayload method or implicitly when one of the write (or writer creation) methods is called.</remarks>
        private ODataPayloadKind writerPayloadKind = ODataPayloadKind.Unsupported;

        /// The <see cref="ODataFormat"/> of the payload to be written with this writer.
        /// <remarks>This is either set via the SetHeadersForPayload method or implicitly when one of the write (or writer creation) methods is called.</remarks>
        private ODataFormat format;

        /// The <see cref="Encoding"/> of the payload to be written with this writer.
        /// <remarks>This is either set via the SetHeadersForPayload method or implicitly when one of the write (or writer creation) methods is called.</remarks>
        private Encoding encoding;

        /// The batch boundary string if the payload to be written is a batch request or response.
        /// <remarks>This is either set via the SetHeadersForPayload method or implicitly when the CreateBatchWriter method is called.</remarks>
        private string batchBoundary;

        /// Flag to prevent writing more than one error to the payload.
        private bool writeErrorCalled;

        ///
        /// Creates a new ODataMessageWriter for the given request message.
        ///
        /// <param name="requestMessage">The request message for which to create the writer.</param>
        public ODataMessageWriter(IODataRequestMessage requestMessage)
            : this(requestMessage, null)
        {
        }

        ///
        /// Creates a new ODataMessageWriter for the given request message and message writer settings.
        ///
        /// <param name="requestMessage">The request message for which to create the writer.</param>
        /// <param name="settings">The message writer settings to use for writing the message payload.</param>
        public ODataMessageWriter(IODataRequestMessage requestMessage, ODataMessageWriterSettings settings)
            : this(requestMessage, settings, null)
        {
        }

        ///
        /// Creates a new ODataMessageWriter for the given request message and message writer settings.
        ///
        /// <param name="requestMessage">The request message for which to create the writer.</param>
        /// <param name="settings">The message writer settings to use for writing the message payload.</param>
        /// <param name="model">The model to use.</param>
        public ODataMessageWriter(IODataRequestMessage requestMessage, ODataMessageWriterSettings settings, IEdmModel model)
        {
            ExceptionUtils.CheckArgumentNotNull(requestMessage, "requestMessage");

            // Clone the settings here so we can later modify them without changing the settings passed to us by the user
            this.settings = settings == null ? new ODataMessageWriterSettings() : new ODataMessageWriterSettings(settings);
            WriterValidationUtils.ValidateMessageWriterSettings(this.settings);

            this.writingResponse = false;
            this.message = new ODataRequestMessage(requestMessage, /*writing*/ true, this.settings.DisableMessageStreamDisposal, /*maxMessageSize*/ -1);
            this.urlResolver = requestMessage as IODataUrlResolver;
            this.model = model ?? EdmCoreModel.Instance;
        }

        ///
        /// Creates a new ODataMessageWriter for the given response message.
        ///
        /// <param name="responseMessage">The response message for which to create the writer.</param>
        public ODataMessageWriter(IODataResponseMessage responseMessage)
            : this(responseMessage, null)
        {
        }

        ///
        /// Creates a new ODataMessageWriter for the given response message and message writer settings.
        ///
        /// <param name="responseMessage">The response message for which to create the writer.</param>
        /// <param name="settings">The message writer settings to use for writing the message payload.</param>
        public ODataMessageWriter(IODataResponseMessage responseMessage, ODataMessageWriterSettings settings)
            : this(responseMessage, settings, null)
        {
        }

        ///
        /// Creates a new ODataMessageWriter for the given response message and message writer settings.
        ///
        /// <param name="responseMessage">The response message for which to create the writer.</param>
        /// <param name="settings">The message writer settings to use for writing the message payload.</param>
        /// <param name="model">The model to use.</param>
        public ODataMessageWriter(IODataResponseMessage responseMessage, ODataMessageWriterSettings settings, IEdmModel model)
        {
            ExceptionUtils.CheckArgumentNotNull(responseMessage, "responseMessage");

            // Clone the settings here so we can later modify them without changing the settings passed to us by the user
            this.settings = settings == null ? new ODataMessageWriterSettings() : new ODataMessageWriterSettings(settings);
            WriterValidationUtils.ValidateMessageWriterSettings(this.settings);

            this.writingResponse = true;
            this.message = new ODataResponseMessage(responseMessage, /*writing*/ true, this.settings.DisableMessageStreamDisposal, /*maxMessageSize*/ -1);
            this.urlResolver = responseMessage as IODataUrlResolver;
            this.model = model ?? EdmCoreModel.Instance;
        }

        ///
        /// Creates an <see cref="ODataWriter" /> to write a feed.
        ///
        /// <returns>The created writer.</returns>
        public ODataWriter CreateODataFeedWriter()
        {
            this.VerifyCanCreateODataFeedWriter();
            return this.WriteToOutput(
                ODataPayloadKind.Feed,
                null /* verifyHeaders */,
                (context) => context.CreateODataFeedWriter());
        }

#if ODATALIB_ASYNC
        ///
        /// Asynchronously creates an <see cref="ODataWriter" /> to write a feed.
        ///
        /// <returns>A running task for the created writer.</returns>
        public Task<ODataWriter> CreateODataFeedWriterAsync()
        {
            this.VerifyCanCreateODataFeedWriter();
            return this.WriteToOutputAsync(
                ODataPayloadKind.Feed,
                null /* verifyHeaders */,
                (context) => context.CreateODataFeedWriterAsync());
        }
#endif

        ///
        /// Creates an <see cref="ODataWriter" /> to write an entry.
        ///
        /// <returns>The created writer.</returns>
        public ODataWriter CreateODataEntryWriter()
        {
            this.VerifyCanCreateODataEntryWriter();
            return this.WriteToOutput(
                ODataPayloadKind.Entry,
                null /* verifyHeaders */,
                (context) => context.CreateODataEntryWriter());
        }

#if ODATALIB_ASYNC
        ///
        /// Asynchronously creates an <see cref="ODataWriter" /> to write an entry.
        ///
        /// <returns>A running task for the created writer.</returns>
        public Task<ODataWriter> CreateODataEntryWriterAsync()
        {
            this.VerifyCanCreateODataEntryWriter();
            return this.WriteToOutputAsync(
                ODataPayloadKind.Entry,
                null /* verifyHeaders */,
                (context) => context.CreateODataEntryWriterAsync());
        }
#endif

        ///
        /// Creates an <see cref="ODataCollectionWriter" /> to write a collection of primitive or complex values (as result of a service operation invocation).
        ///
        /// <returns>The created collection writer.</returns>
        public ODataCollectionWriter CreateODataCollectionWriter()
        {
            this.VerifyCanCreateODataCollectionWriter();
            return this.WriteToOutput(
                ODataPayloadKind.Collection,
                null /* verifyHeaders */,
                (context) => context.CreateODataCollectionWriter());
        }

#if ODATALIB_ASYNC
        ///
        /// Asynchronously creates an <see cref="ODataCollectionWriter" /> to write a collection of primitive or complex values (as result of a service operation invocation).
        ///
        /// <returns>A running task for the created collection writer.</returns>
        public Task<ODataCollectionWriter> CreateODataCollectionWriterAsync()
        {
            this.VerifyCanCreateODataCollectionWriter();
            return this.WriteToOutputAsync(
                ODataPayloadKind.Collection,
                null /* verifyHeaders */,
                (context) => context.CreateODataCollectionWriterAsync());
        }
#endif

        ///
        /// Creates an <see cref="ODataBatchWriter" /> to write a batch of requests or responses.
        ///
        /// <returns>The created batch writer.</returns>
        public ODataBatchWriter CreateODataBatchWriter()
        {
            this.VerifyCanCreateODataBatchWriter();
            return this.WriteToOutput(
                ODataPayloadKind.Batch,
                null /* verifyHeaders */,
                (context) => context.CreateODataBatchWriter(this.batchBoundary));
        }

#if ODATALIB_ASYNC
        ///
        /// Asynchronously creates an <see cref="ODataBatchWriter" /> to write a batch of requests or responses.
        ///
        /// <returns>A running task for the created batch writer.</returns>
        public Task<ODataBatchWriter> CreateODataBatchWriterAsync()
        {
            this.VerifyCanCreateODataBatchWriter();
            return this.WriteToOutputAsync(
                ODataPayloadKind.Batch,
                null /* verifyHeaders */,
                (context) => context.CreateODataBatchWriterAsync(this.batchBoundary));
        }
#endif

        ///
        /// Creates an <see cref="ODataParameterWriter" /> to write a parameter payload.
        ///
        /// <param name="functionImport">The function import whose parameters will be written.</param>
        /// <returns>The created parameter writer.</returns>
        public ODataParameterWriter CreateODataParameterWriter(IEdmFunctionImport functionImport)
        {
            this.VerifyCanCreateODataParameterWriter(functionImport);
            return this.WriteToOutput(
                ODataPayloadKind.Parameter,
                this.VerifyODataParameterWriterHeaders,
                (context) => context.CreateODataParameterWriter(functionImport));
        }

#if ODATALIB_ASYNC
        ///
        /// Asynchronously creates an <see cref="ODataParameterWriter" /> to write a parameter payload.
        ///
        /// <param name="functionImport">The function import whose parameters will be written.</param>
        /// <returns>A running task for the created parameter writer.</returns>
        public Task<ODataParameterWriter> CreateODataParameterWriterAsync(IEdmFunctionImport functionImport)
        {
            this.VerifyCanCreateODataParameterWriter(functionImport);
            return this.WriteToOutputAsync(
                ODataPayloadKind.Parameter,
                this.VerifyODataParameterWriterHeaders,
                (context) => context.CreateODataParameterWriterAsync(functionImport));
        }
#endif

        ///
        /// Writes a service document with the specified <paramref name="defaultWorkspace"/>
        /// as message payload.
        ///
        /// <param name="defaultWorkspace">The default workspace to write in the service document.</param>
        public void WriteServiceDocument(ODataWorkspace defaultWorkspace)
        {
            this.VerifyCanWriteServiceDocument(defaultWorkspace);
            this.WriteToOutput(
                ODataPayloadKind.ServiceDocument,
                null /* verifyHeaders */,
                (context) => context.WriteServiceDocument(defaultWorkspace));
        }

#if ODATALIB_ASYNC
        ///
        /// Asynchronously writes a service document with the specified <paramref name="defaultWorkspace"/>
        /// as message payload.
        ///
        /// <param name="defaultWorkspace">The default workspace to write in the service document.</param>
        /// <returns>A task representing the asynchronous operation of writing the service document.</returns>
        public Task WriteServiceDocumentAsync(ODataWorkspace defaultWorkspace)
        {
            this.VerifyCanWriteServiceDocument(defaultWorkspace);
            return this.WriteToOutputAsync(
                ODataPayloadKind.ServiceDocument,
                null /* verifyHeaders */,
                (context) => context.WriteServiceDocumentAsync(defaultWorkspace));
        }
#endif

        ///
        /// Writes an <see cref="ODataProperty"/> as message payload.
        ///
        /// <param name="property">The property to write.</param>
        public void WriteProperty(ODataProperty property)
        {
            this.VerifyCanWriteProperty(property);
            this.WriteToOutput(
                ODataPayloadKind.Property,
                null /* verifyHeaders */,
                (context) => context.WriteProperty(property));
        }

#if ODATALIB_ASYNC
        ///
        /// Asynchronously writes an <see cref="ODataProperty"/> as message payload.
        ///
        /// <param name="property">The property to write</param>
        /// <returns>A task representing the asynchronous operation of writing the property.</returns>
        public Task WritePropertyAsync(ODataProperty property)
        {
            this.VerifyCanWriteProperty(property);
            return this.WriteToOutputAsync(
                ODataPayloadKind.Property,
                null /* verifyHeaders */,
                (context) => context.WritePropertyAsync(property));
        }
#endif

        ///
        /// Writes an <see cref="ODataError"/> as the message payload.
        ///
        /// <param name="error">The error to write.</param>
        /// <param name="includeDebugInformation">
        /// A flag indicating whether debug information (e.g., the inner error from the <paramref name="error"/>) should
        /// be included in the payload. This should only be used in debug scenarios.
        /// </param>
        public void WriteError(ODataError error, bool includeDebugInformation)
        {
            // We currently assume that the error is top-level if no create/write method has been called on this message writer.
            // It is possible that the user would create a Json writer, but writes nothing to it before writes the first error.
            // For example it is valid to call CreateEntryWriter() and then WriteError(). In that case the Json payload would
            // contain just an error without the Json wrapper.
            if (this.outputContext == null)
            {
                // Top-level error
                this.VerifyCanWriteTopLevelError(error);
                this.WriteToOutput(
                    ODataPayloadKind.Error,
                    null /* verifyHeaders */,
                    (context) => context.WriteError(error, includeDebugInformation));
                return;
            }

            // In-stream error
            this.VerifyCanWriteInStreamError(error);
            this.outputContext.WriteInStreamError(error, includeDebugInformation);
        }

#if ODATALIB_ASYNC
        ///
        /// Asynchronously writes an <see cref="ODataError"/> as the message payload.
        ///
        /// <param name="error">The error to write.</param>
        /// <param name="includeDebugInformation">
        /// A flag indicating whether debug information (e.g., the inner error from the <paramref name="error"/>) should
        /// be included in the payload. This should only be used in debug scenarios.
        /// </param>
        /// <returns>A task representing the asynchronous operation of writing the error.</returns>
        public Task WriteErrorAsync(ODataError error, bool includeDebugInformation)
        {
            // We currently assume that the error is top-level if no create/write method has been called on this message writer.
            // It is possible that the user would create a Json writer, but writes nothing to it before writes the first error.
            // For example it is valid to call CreateEntryWriter() and then WriteError(). In that case the Json payload would
            // contain just an error without the Json wrapper.
            if (this.outputContext == null)
            {
                // Top-level error
                this.VerifyCanWriteTopLevelError(error);
                return this.WriteToOutputAsync(
                    ODataPayloadKind.Error,
                    null /* verifyHeaders */,
                    (context) => context.WriteErrorAsync(error, includeDebugInformation));
            }

            // In-stream error
            this.VerifyCanWriteInStreamError(error);
            return this.outputContext.WriteInStreamErrorAsync(error, includeDebugInformation);
        }
#endif

        ///
        /// Writes the result of a $links query as the message payload.
        ///
        /// <param name="links">The entity reference links to write as message payload.</param>
        public void WriteEntityReferenceLinks(ODataEntityReferenceLinks links)
        {
            this.VerifyCanWriteEntityReferenceLinks(links);
            this.WriteToOutput(
                ODataPayloadKind.EntityReferenceLinks,
                () => this.VerifyEntityReferenceLinksHeaders(links),
                (context) => context.WriteEntityReferenceLinks(links));
        }

#if ODATALIB_ASYNC
        ///
        /// Asynchronously writes the result of a $links query as the message payload.
        ///
        /// <param name="links">The entity reference links to write as message payload.</param>
        /// <returns>A task representing the asynchronous writing of the entity reference links.</returns>
        public Task WriteEntityReferenceLinksAsync(ODataEntityReferenceLinks links)
        {
            this.VerifyCanWriteEntityReferenceLinks(links);
            return this.WriteToOutputAsync(
                ODataPayloadKind.EntityReferenceLinks,
                () => this.VerifyEntityReferenceLinksHeaders(links),
                (context) => context.WriteEntityReferenceLinksAsync(links));
        }
#endif

        ///
        /// Writes a singleton result of a $links query as the message payload.
        ///
        /// <param name="link">The entity reference link to write as message payload.</param>
        public void WriteEntityReferenceLink(ODataEntityReferenceLink link)
        {
            this.VerifyCanWriteEntityReferenceLink(link);
            this.WriteToOutput(
                ODataPayloadKind.EntityReferenceLink,
                null /* verifyHeaders */,
                (context) => context.WriteEntityReferenceLink(link));
        }

#if ODATALIB_ASYNC
        ///
        /// Asynchronously writes a singleton result of a $links query as the message payload.
        ///
        /// <param name="link">The link result to write as message payload.</param>
        /// <returns>A running task representing the writing of the link.</returns>
        public Task WriteEntityReferenceLinkAsync(ODataEntityReferenceLink link)
        {
            this.VerifyCanWriteEntityReferenceLink(link);
            return this.WriteToOutputAsync(
                ODataPayloadKind.EntityReferenceLink,
                null /* verifyHeaders */,
                (context) => context.WriteEntityReferenceLinkAsync(link));
        }
#endif

        ///
        /// Writes a single value as the message body.
        ///
        /// <param name="value">The value to write.</param>
        public void WriteValue(object value)
        {
            ODataPayloadKind payloadKind = this.VerifyCanWriteValue(value);
            this.WriteToOutput(
                payloadKind,
                null /* verifyHeaders */,
                (context) => context.WriteValue(value));
        }

#if ODATALIB_ASYNC
        ///
        /// Asynchronously writes a single value as the message body.
        ///
        /// <param name="value">The value to write.</param>
        /// <returns>A running task representing the writing of the value.</returns>
        public Task WriteValueAsync(object value)
        {
            ODataPayloadKind payloadKind = this.VerifyCanWriteValue(value);
            return this.WriteToOutputAsync(
                payloadKind,
                null /* verifyHeaders */,
                (context) => context.WriteValueAsync(value));
        }
#endif

        ///
        /// Writes the metadata document as the message body.
        ///
        public void WriteMetadataDocument()
        {
            this.VerifyCanWriteMetadataDocument();
            this.WriteToOutput(
                ODataPayloadKind.MetadataDocument,
                this.VerifyMetadataDocumentHeaders,
                (context) => context.WriteMetadataDocument());
        }

        ///
        /// IDisposable.Dispose() implementation to cleanup unmanaged resources of the writer.
        ///
        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }

        ///
        /// Sets the content-type and data service version headers on the message used by the message writer.
        /// This method can be called if it is important to set all the message headers before calling any of the
        /// write (or writer creation) methods on the <see cref="ODataMessageWriter"/>.
        /// If it is sufficient to set the headers when the write (or writer creation) methods on the <see cref="ODataMessageWriter"/>
        /// are called, you don't have to call this method and setting the headers will happen automatically.
        ///
        /// <param name="payloadKind">The kind of payload to be written with this message writer.</param>
        /// <returns>The <see cref="ODataFormat"/> used for the specified <paramref name="payloadKind"/>.</returns>
        internal ODataFormat SetHeaders(ODataPayloadKind payloadKind)
        {
            DebugUtils.CheckNoExternalCallers();
            Debug.Assert(payloadKind != ODataPayloadKind.Unsupported, "payloadKind != ODataPayloadKind.Unsupported");

            this.writerPayloadKind = payloadKind;

            // Make sure we have a version set on the message writer settings; if none was specified on the settings, try to read
            // it from the message headers. If not specified in the headers either, fall back to a default.
            // NOTE: This method will potentially also set the data service version header.
            this.EnsureODataVersion();
            Debug.Assert(this.settings.Version.HasValue, "ODataVersion must have been set by now.");

            // Make sure we have a content-type and compute the format from the settings and/or the message headers.
            // NOTE: This method will potentially also set the content type header.
            this.EnsureODataFormatAndContentType();
            return this.format;
        }

        ///
        /// If no headers have been set, sets the content-type and data service version headers on the message used by the message writer.
        /// If headers have been set explicitly (via ODataUtils.SetHeaderForPayload) this method verifies that the payload kind used to
        /// create the headers is the same as the one being passed in <paramref name="payloadKind"/>.
        ///
        /// <param name="payloadKind">The kind of payload to be written with this message writer.</param>
        private void SetOrVerifyHeaders(ODataPayloadKind payloadKind)
        {
            DebugUtils.CheckNoExternalCallers();
            Debug.Assert(payloadKind != ODataPayloadKind.Unsupported, "payloadKind != ODataPayloadKind.Unsupported");

            // verify that no payload kind has been set or that the payload kind set previously and the
            // payload that is attempted to being written are the same
            this.VerifyPayloadKind(payloadKind);

            if (this.writerPayloadKind == ODataPayloadKind.Unsupported)
            {
                // no payload kind or headers have been set; set them now
                this.SetHeaders(payloadKind);
            }
        }

        ///
        /// Ensures that the version of the OData protocol is set.
        ///
        /// <remarks>
        /// If a version is specified explicitly on the writer settings, it is used.
        /// Otherwise the method tries to read the version from the message headers.
        /// If there is a version header but the value cannot be parsed, we fail.
        /// If there is no version header, we fall back to the default version.
        /// </remarks>
        private void EnsureODataVersion()
        {
            // if no version was specified in the user settings, try to read it from the message headers
            if (!this.settings.Version.HasValue)
            {
                // Read the version header and parse it; fail if we can't parse it.
                // Fall back to a default if we don't find a version header.
                this.settings.Version = ODataUtilsInternal.GetDataServiceVersion(this.message, ODataConstants.ODataDefaultProtocolVersion);
                Debug.Assert(this.settings.Version.HasValue, "The version must have been set by now.");
            }
            else
            {
                // Set the data service version
                ODataUtilsInternal.SetDataServiceVersion(this.message, this.settings);
            }

            // If the version is set to >= 3.0 we must not have a format behavior other than the default behavior.
            // Custom format behaviors for the WCF DS client and server are only supported in versions < 3.0
            if (this.settings.Version >= ODataVersion.V3 && this.settings.WriterBehavior.FormatBehaviorKind != ODataBehaviorKind.Default)
            {
                this.settings.WriterBehavior.UseDefaultFormatBehavior();
            }
        }

        ///
        /// Ensures that the OData format is computed and set; if needed, sets the content type
        /// header of the message.
        ///
        /// <remarks>
        /// This method computes and ensures that a content type exists and computes the
        /// OData format from it. If a content type is explicitly specified through
        /// <see cref="Microsoft.Data.OData.ODataUtils.SetHeadersForPayload(Microsoft.Data.OData.ODataMessageWriter, Microsoft.Data.OData.ODataPayloadKind)"/>
        /// or <see cref="Microsoft.Data.OData.ODataMessageWriterSettings.SetContentType(string, string)"/> it will be used. If no
        /// content type is specified in either place, the message headers are checked for
        /// a content type header.
        /// If the content type is computed from settings, the content type header is set on the message.
        /// </remarks>
        private void EnsureODataFormatAndContentType()
        {
            Debug.Assert(this.writerPayloadKind != ODataPayloadKind.Unsupported, "Writer payload kind should have been set by now.");

            string contentType = null;

            // If neither format nor accept headers were specified in the writer settings, try to read the content type from the message headers.
            if (!this.settings.UseFormat.HasValue)
            {
                contentType = this.message.GetHeader(ODataConstants.ContentTypeHeader);
                contentType = contentType == null ? null : contentType.Trim();
            }

            // If we found a content type header, use it. Otherwise use the default behavior.
            if (!string.IsNullOrEmpty(contentType))
            {
                ODataPayloadKind computedPayloadKind;
                MediaType mediaType;
                this.format = MediaTypeUtils.GetFormatFromContentType(contentType, new ODataPayloadKind[] { this.writerPayloadKind }, MediaTypeResolver.DefaultMediaTypeResolver, out mediaType, out this.encoding, out computedPayloadKind, out this.batchBoundary);
                Debug.Assert(this.writerPayloadKind == computedPayloadKind, "The payload kinds must always match.");
            }
            else
            {
                // Determine the content type and format from the settings. Note that if neither format nor accept headers have been specified in the settings
                // we fall back to a default (of null accept headers).
                MediaType mediaType;
                this.format = MediaTypeUtils.GetContentTypeFromSettings(this.settings, this.writerPayloadKind, MediaTypeResolver.DefaultMediaTypeResolver, out mediaType, out this.encoding);

                if (this.writerPayloadKind == ODataPayloadKind.Batch)
                {
                    // Note that this serves as verification only for now, since we only support a single content type and format for $batch payloads.
                    Debug.Assert(this.format == ODataFormat.Batch, "$batch should only support batch format since it's format independent.");
                    Debug.Assert(mediaType.FullTypeName == MimeConstants.MimeMultipartMixed, "$batch content type is currently only supported to be multipart/mixed.");

                    this.batchBoundary = ODataBatchWriterUtils.CreateBatchBoundary(this.writingResponse);

                    // Set the content type header here since all headers have to be set before getting the stream
                    // Note that the mediaType may have additional parameters, which we ignore here (intentional as per MIME spec).
                    // Note that we always generate a new boundary string here, even if the accept header contained one.
                    // We need the boundary to be as unique as possible to avoid possible collision with content of the batch operation payload.
                    // Our boundary string are generated to fulfill this requirement, client specified ones might not which might lead to wrong responses
                    // and at least in theory security issues.
                    contentType = ODataBatchWriterUtils.CreateMultipartMixedContentType(this.batchBoundary);
                }
                else
                {
                    this.batchBoundary = null;

                    // Compute the content type (incl. charset) and set the Content-Type header on the response message
                    contentType = HttpUtils.BuildContentType(mediaType, this.encoding);
                }

                // NOTE: set the content type header here since all headers have to be set before getting the stream
                this.message.SetHeader(ODataConstants.ContentTypeHeader, contentType);
            }
        }

        ///
        /// Verifies that feed writer can be created.
        ///
        private void VerifyCanCreateODataFeedWriter()
        {
            this.VerifyWriterNotDisposedAndNotUsed();
        }

        ///
        /// Verifies that entry writer can be created.
        ///
        private void VerifyCanCreateODataEntryWriter()
        {
            this.VerifyWriterNotDisposedAndNotUsed();
        }

        ///
        /// Verifies that collection writer can be created.
        ///
        private void VerifyCanCreateODataCollectionWriter()
        {
            this.VerifyWriterNotDisposedAndNotUsed();
        }

        ///
        /// Verifies that batch writer can be created.
        ///
        private void VerifyCanCreateODataBatchWriter()
        {
            this.VerifyWriterNotDisposedAndNotUsed();
        }

        ///
        /// Verifies that parameter writer can be created.
        ///
        /// <param name="functionImport">The function import whose parameters will be written.</param>
        private void VerifyCanCreateODataParameterWriter(IEdmFunctionImport functionImport)
        {
            if (this.writingResponse)
            {
                throw new ODataException(Strings.ODataParameterWriter_CannotCreateParameterWriterOnResponseMessage);
            }

            if (functionImport != null)
            {
                // check that we have a user model
                if (!this.model.IsUserModel())
                {
                    throw new ODataException(Strings.ODataMessageWriter_CannotSpecifyFunctionImportWithoutModel);
                }
            }

            this.VerifyWriterNotDisposedAndNotUsed();
        }

        ///
        /// Verifies headers for parameter payload.
        ///
        private void VerifyODataParameterWriterHeaders()
        {
            ODataVersionChecker.CheckParameterPayload(this.settings.Version.Value);
        }

        ///
        /// Verifies that service document can be written.
        ///
        /// <param name="defaultWorkspace">The default workspace to write.</param>
        private void VerifyCanWriteServiceDocument(ODataWorkspace defaultWorkspace)
        {
            ExceptionUtils.CheckArgumentNotNull(defaultWorkspace, "defaultWorkspace");

            if (!this.writingResponse)
            {
                throw new ODataException(Strings.ODataMessageWriter_ServiceDocumentInRequest);
            }

            // VerifyWriterNotDisposedAndNotUsed changes the state of the message writer, it should be called after
            // we check the error conditions above.
            this.VerifyWriterNotDisposedAndNotUsed();
        }

        ///
        /// Verifies that property can be written.
        ///
        /// <param name="property">The property to write.</param>
        private void VerifyCanWriteProperty(ODataProperty property)
        {
            ExceptionUtils.CheckArgumentNotNull(property, "property");

            if (property.Value is ODataStreamReferenceValue)
            {
                throw new ODataException(Strings.ODataMessageWriter_CannotWriteStreamPropertyAsTopLevelProperty(property.Name));
            }

            this.VerifyWriterNotDisposedAndNotUsed();
        }

        ///
        /// Verifies that top-level error can be written.
        ///
        /// <param name="error">The error to write.</param>
        private void VerifyCanWriteTopLevelError(ODataError error)
        {
            ExceptionUtils.CheckArgumentNotNull(error, "error");

            if (!this.writingResponse)
            {
                // errors can only be written for response messages
                throw new ODataException(Strings.ODataMessageWriter_ErrorPayloadInRequest);
            }

            // Note that this verifies that the writer is only used once, so it also verifies that
            // there's nothing written before the error.
            this.VerifyWriterNotDisposedAndNotUsed();

            // Mark it as error written so that we don't allow writing in-stream errors after this.
            this.writeErrorCalled = true;
        }

        ///
        /// Verifies that in-stream error can be written.
        ///
        /// <param name="error">The error to write.</param>
        private void VerifyCanWriteInStreamError(ODataError error)
        {
            ExceptionUtils.CheckArgumentNotNull(error, "error");

            this.VerifyNotDisposed();

            if (!this.writingResponse)
            {
                // errors can only be written for response messages
                throw new ODataException(Strings.ODataMessageWriter_ErrorPayloadInRequest);
            }

            if (this.writeErrorCalled)
            {
                throw new ODataException(Strings.ODataMessageWriter_WriteErrorAlreadyCalled);
            }

            this.writeErrorCalled = true;

            // Need to mark the writer as already used, so that we don't allow any other calls to it.
            this.writeMethodCalled = true;
        }

        ///
        /// Verifies that entity reference links can be written.
        ///
        /// <param name="links">The entity reference links to write as message payload.</param>
        private void VerifyCanWriteEntityReferenceLinks(ODataEntityReferenceLinks links)
        {
            // NOTE: we decided to not stream links for now but only make writing them async.
            ExceptionUtils.CheckArgumentNotNull(links, "links");

            if (!this.writingResponse)
            {
                throw new ODataException(Strings.ODataMessageWriter_EntityReferenceLinksInRequestNotAllowed);
            }

            // VerifyWriterNotDisposedAndNotUsed changes the state of the message writer, it should be called after
            // we check the error conditions above.
            this.VerifyWriterNotDisposedAndNotUsed();
        }

        ///
        /// Verifies headers for entity reference links.
        ///
        /// <param name="links">The entity reference links to write as message payload.</param>
        private void VerifyEntityReferenceLinksHeaders(ODataEntityReferenceLinks links)
        {
            Debug.Assert(this.settings != null && this.settings.Version.HasValue, "Settings must have been created and the version set.");

            if (links.Count.HasValue)
            {
                ODataVersionChecker.CheckCount(this.settings.Version.Value);
            }

            if (links.NextPageLink != null)
            {
                ODataVersionChecker.CheckNextLink(this.settings.Version.Value);
            }
        }

        ///
        /// Verifies that entity reference link can be written.
        ///
        /// <param name="link">The link result to write as message payload.</param>
        private void VerifyCanWriteEntityReferenceLink(ODataEntityReferenceLink link)
        {
            ExceptionUtils.CheckArgumentNotNull(link, "link");

            this.VerifyWriterNotDisposedAndNotUsed();
        }

        ///
        /// Verifies that value can be written.
        ///
        /// <param name="value">The value to write.</param>
        /// <returns>The payload kind to use when writing this value.</returns>
        private ODataPayloadKind VerifyCanWriteValue(object value)
        {
            if (value == null)
            {
                throw new ODataException(Strings.ODataMessageWriter_CannotWriteNullInRawFormat);
            }

            this.VerifyWriterNotDisposedAndNotUsed();

            // We cannot use AtomValueUtils.TryConvertPrimitiveToString for all cases since binary values are
            // converted into unencoded byte streams in the raw format
            // (as opposed to base64 encoded byte streams in the AtomValueUtils); see OIPI 2.2.6.4.1.
            return value is byte[] ? ODataPayloadKind.BinaryValue : ODataPayloadKind.Value;
        }

        ///
        /// Verifies that metadata document can be written.
        ///
        private void VerifyCanWriteMetadataDocument()
        {
            if (!this.writingResponse)
            {
                throw new ODataException(Strings.ODataMessageWriter_MetadataDocumentInRequest);
            }

            // check that we have a user model
            if (!this.model.IsUserModel())
            {
                throw new ODataException(Strings.ODataMessageWriter_CannotWriteMetadataWithoutModel);
            }

            // VerifyWriterNotDisposedAndNotUsed changes the state of the message writer, it should be called after
            // we check the error conditions above.
            this.VerifyWriterNotDisposedAndNotUsed();
        }

        ///
        /// Verifies headers for metadata document.
        ///
        private void VerifyMetadataDocumentHeaders()
        {
            // set the data service version on the model (if not already present)
            Version dataServiceVersion = this.model.GetDataServiceVersion();
            if (dataServiceVersion == null)
            {
                dataServiceVersion = this.settings.Version.Value.ToDataServiceVersion();
                this.model.SetDataServiceVersion(dataServiceVersion);
            }
        }

        ///
        /// Verifies that the ODataMessageWriter has not been disposed and has not been used before. An ODataMessageWriter
        /// can only be used to write a single message payload but can't be reused later except for writing an in-stream error.
        ///
        private void VerifyWriterNotDisposedAndNotUsed()
        {
            this.VerifyNotDisposed();
            if (this.writeMethodCalled)
            {
                throw new ODataException(Strings.ODataMessageWriter_WriterAlreadyUsed);
            }

            this.writeMethodCalled = true;
        }

        ///
        /// Check if the object has been disposed. Throws an ObjectDisposedException if the object has already been disposed.
        ///
        private void VerifyNotDisposed()
        {
            if (this.isDisposed)
            {
                throw new ObjectDisposedException(this.GetType().FullName);
            }
        }

        ///
        /// Perform the actual cleanup work.
        ///
        /// <param name="disposing">If 'true' this method is called from user code; if 'false' it is called by the runtime.</param>
        private void Dispose(bool disposing)
        {
            this.isDisposed = true;
            if (disposing)
            {
                try
                {
                    if (this.outputContext != null)
                    {
                        this.outputContext.Dispose();
                    }
                }
                finally
                {
                    this.outputContext = null;
                }
            }
        }

        ///
        /// Verifies that, if a payload kind has been set via SetHeaders, the payload kind that
        /// is being written is the same.
        ///
        /// <param name="payloadKindToWrite">The payload kind that is attempted to write.</param>
        private void VerifyPayloadKind(ODataPayloadKind payloadKindToWrite)
        {
            Debug.Assert(payloadKindToWrite != ODataPayloadKind.Unsupported, "payloadKindToWrite != ODataPayloadKind.Unsupported");

            if (this.writerPayloadKind != ODataPayloadKind.Unsupported && this.writerPayloadKind != payloadKindToWrite)
            {
                // if a payload kind has been set via SetHeaders that is not the same as the payload kind
                // that is attempted to write, we fail.
                throw new ODataException(Strings.ODataMessageWriter_IncompatiblePayloadKinds(this.writerPayloadKind, payloadKindToWrite));
            }
        }

        ///
        /// Creates an output context and invokes a write operation on it.
        ///
        /// <param name="payloadKind">The payload kind to write.</param>
        /// <param name="verifyHeaders">Optional action which will be called after the headers has been verified to perform payload specific verification.</param>
        /// <param name="writeAction">The write operation to invoke on the output.</param>
        private void WriteToOutput(ODataPayloadKind payloadKind, Action verifyHeaders, Action<ODataOutputContext> writeAction)
        {
            // Set the content type header here since all headers have to be set before getting the stream
            this.SetOrVerifyHeaders(payloadKind);

            if (verifyHeaders != null)
            {
                verifyHeaders();
            }

            // Create the output context
            this.outputContext = ODataOutputContext.CreateOutputContext(
                this.format,
                this.message,
                this.encoding,
                this.settings,
                this.writingResponse,
                this.model,
                this.urlResolver);
            writeAction(this.outputContext);
        }

        ///
        /// Creates an output context and invokes a write operation on it.
        ///
        /// <typeparam name="TResult">The type of the result of the write operation.</typeparam>
        /// <param name="payloadKind">The payload kind to write.</param>
        /// <param name="verifyHeaders">Optional action which will be called after the headers has been verified to perform payload specific verification.</param>
        /// <param name="writeFunc">The write operation to invoke on the output.</param>
        /// <returns>The result of the write operation.</returns>
        private TResult WriteToOutput<TResult>(ODataPayloadKind payloadKind, Action verifyHeaders, Func<ODataOutputContext, TResult> writeFunc)
        {
            // Set the content type header here since all headers have to be set before getting the stream
            this.SetOrVerifyHeaders(payloadKind);

            if (verifyHeaders != null)
            {
                verifyHeaders();
            }

            // Create the output context
            this.outputContext = ODataOutputContext.CreateOutputContext(
                this.format,
                this.message,
                this.encoding,
                this.settings,
                this.writingResponse,
                this.model,
                this.urlResolver);
            return writeFunc(this.outputContext);
        }

#if ODATALIB_ASYNC
        ///
        /// Creates an output context and invokes a write operation on it.
        ///
        /// <param name="payloadKind">The payload kind to write.</param>
        /// <param name="verifyHeaders">Optional action which will be called after the headers has been verified to perform payload specific verification.</param>
        /// <param name="writeAsyncAction">The write operation to invoke on the output.</param>
        /// <returns>Task which represents the pending write operation.</returns>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "The output context is disposed by Dispose on the writer.")]
        private Task WriteToOutputAsync(ODataPayloadKind payloadKind, Action verifyHeaders, Func<ODataOutputContext, Task> writeAsyncAction)
        {
            // Set the content type header here since all headers have to be set before getting the stream
            this.SetOrVerifyHeaders(payloadKind);

            if (verifyHeaders != null)
            {
                verifyHeaders();
            }

            // Create the output context
            return ODataOutputContext.CreateOutputContextAsync(
                this.format,
                this.message,
                this.encoding,
                this.settings,
                this.writingResponse,
                this.model,
                this.urlResolver)

                .FollowOnSuccessWithTask(
                    (createOutputContextTask) =>
                    {
                        this.outputContext = createOutputContextTask.Result;
                        return writeAsyncAction(this.outputContext);
                    });
        }

        ///
        /// Creates an output context and invokes a write operation on it.
        ///
        /// <typeparam name="TResult">The type of the result of the write operation.</typeparam>
        /// <param name="payloadKind">The payload kind to write.</param>
        /// <param name="verifyHeaders">Optional action which will be called after the headers has been verified to perform payload specific verification.</param>
        /// <param name="writeFunc">The write operation to invoke on the output.</param>
        /// <returns>Task which represents the pending write operation.</returns>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "The output context is disposed by Dispose on the writer.")]
        private Task<TResult> WriteToOutputAsync<TResult>(ODataPayloadKind payloadKind, Action verifyHeaders, Func<ODataOutputContext, Task<TResult>> writeFunc)
        {
            // Set the content type header here since all headers have to be set before getting the stream
            this.SetOrVerifyHeaders(payloadKind);

            if (verifyHeaders != null)
                    {
                verifyHeaders();
            }

            // Create the output context
            return ODataOutputContext.CreateOutputContextAsync(
                this.format,
                this.message,
                this.encoding,
                this.settings,
                this.writingResponse,
                this.model,
                this.urlResolver)

                .FollowOnSuccessWithTask(
                    (createOutputContextTask) =>
                    {
                        this.outputContext = createOutputContextTask.Result;
                        return writeFunc(this.outputContext);
                    });
            }
#endif
    }
}


여기, Race n Chase 3D Car Racing Game 및 수많은 앱에 대한 모든 정보가 있습니다. 무료로 가입하고 관심 있는 앱들에 대한 정보와 경쟁자의 인사이트, 앱 업계 현황에 대해 알아보세요.
미국에서 Race n Chase 3D Car Racing Game 의 다운로드 순위 기록을 확인하세요.
순위 기록은 Mac 앱 스토어에서 Race n Chase 3D Car Racing Game의 인기와 시간에 따른 인기의 변화를 보여줍니다. 또한, 국가, 카테고리, 기기에 따른 Race n Chase 3D Car Racing Game 의 일일 성과를 추적할 수 있습니다.
Race-n-Chase, is 3D car racing game in a beautiful and unique race track! The game features rain or day mode with six different camera views and your choice of car colors.
Race along with other artificial intelligence (AI) cars for the desired number of laps.
Be a smart driver, don't hit your opponent or you may get some scratches and fire sparks on your baby. Enjoy the rally action packed ride!!


A pool in your backyard is great to enjoy and relax after a day of work. Pool owners need to maintain and take care of the pool to keep it clean and refreshing. Maintaining a pool is not as difficult one might think. Pools often get hazy and unhygienic if not maintained and cleaned, even if left idle for a month.
If you have a pool in your house, you can always contact a pool service agency to take care of your pool, but still, there are some things you need to do yourself. You should try these ten pool care tips to maintain and keep it sparkling clean all the times.
Skimming the debris from the surface of a pool is essential to keep the water clean all the time. If you don't skim the debris regularly, it will sink into the pool, and it becomes difficult to remove it. You can use a long-handled hand skimmer to remove the unwanted debris, bugs, and leaves from the water. Cleaning the debris from the water also helps the circulation system work more effectively.
Filters remove the dirt, leaves and many unwanted things from the pool water. The filters installed in your pool require cleaning at regular intervals. Every filter is different and requires a specific maintenance process to clean. If you clean the filter on your own, you should read their manual and follow the instructions. If you use the pool frequently, you should clean the filters at least once a week, so that they perform their task effectively.
The sides of the pool also need to be cleaned regularly to prevent the formation of algae. You need to brush the walls and tiles of the pool to minimize the calcium deposits and algae. Also, you should use a soft brush to clean the tiles. A soft brush takes time to clean the tiles, but it does not leave scratches or degrade the grout between the tiles. Use a pool tile cleaner to clean the walls and tiles of the pool.
You should get your pool vacuumed to clean its surface once in a week or ten days. Vacuuming of the pool keeps the water clean and prevents the formation of algae on the pool surface. It is essential to check the filter of the vacuum every time and clean it if it requires cleaning. Also, you should add some algaecide to prevent the formation of algae on the surface and walls.
You need to maintain the pH level (alkalinity) of your pool water. The pH level of the water in your pool should be between 7.2 and 7.8. If the pH level of the water is higher than 7.8, you need to add some sodium bisulfate or muriatic acid to reduce the alkalinity. If the pH level of water is less than 7.2, you should add sodium carbonate to increase it. Maintaining proper pH level also protects the pool equipment from corrosion.
It is essential to check the chlorine levels of the pool water as chlorine kills the harmful germs in water. The chlorine level should always be between 1 part per million and 3 parts per million. If the salt water chlorinator level is less than 1ppm, you need to add some chlorine to maintain its level in the pool water.
The regular checking of chemical levels and unwanted matter in water is essential for pool maintenance. You should check the levels of chlorine, alkalinity, and acids in the water and add the chemicals as required. Test the chemicals with a testing kit by filling it with a sample of pool water and comparing the colors of the sample with the colors given on the kit.
Sometimes when you party at your pool, the water becomes more hazy and cloudy with a lot of debris and bacteria. You need to give a shock treatment to your pool to clean the water. Shock treatment also known as superchlorination means adding chlorine more than the normal levels to kill the germs and clear the contaminants. You should follow the instructions on the shock treatment kit before super chlorinating your pool.
Maintaining your pool is essential to enjoy using it in all the seasons. Checking the levels of chemicals and water will help you maintain the water free from bacteria and germs. Regular cleaning of filters, surface, and walls of the pool helps you to keep the water sparkling clean. Whether you use your pool regularly or occasionally, you need to spend time and money to maintain it.


text:
pronoun – "wrong"
New Music May 9, 2018 11:00 AM By James Rettig
A couple months ago, Alyse Vellturo released "run," the first song from her project, pronoun, since its debut EP, 2016's There's no one new around you. She's back with another new one today, "wrong," that's just as soaring and persistently catchy as the rest of her music. It's about regret and recognition, seeing the same qualities you dislike about yourself reflected in someone else and feeling sympathy for them despite not liking them anymore. "You can't go backwards/ Guess I couldn't ever relate/ Now I'm sitting feeling sorry/ For somebody that I hate/ And it feels so wrong," Vellturo sings in the chorus, her words wrapping around each other.
The song is about the complicated mess of emotions directed towards an ex-girlfriend, as Vellturo explains in a statement: "For the longest time I was so angry at her, and the news that should have been the final straw actually just made me feel really bad for her which spun me in to the weird emotion of how can you feel sorry for some one you "hate"? How is that even possible, do other people feel this way? I guess in a way it's what I would want to say if I wanted to talk to her–which obviously I don't–so I wrote this song instead."
Listen to the track below.
"wrong" is out now. pronoun's debut album is due out later this year via Rhyme & Reason Records.
James Rettig Staff jamsrettig
Two German Festivals Drop Pantera From Lineups After Other Artists Express Concerns
20 Great David Crosby Moments
Panic! At The Disco Call It Quits
The Number Ones: James Blunt's "You're Beautiful"
Succumb To Our Email Product
The most important stories and least important memes, every Friday.
Please disable your adblocker or subscribe to ad-free membership to view this article.
Already a VIP? Sign in.

redpajama_set_name: RedPajamaCommonCrawl


text:
Apple exec explains why the company has not brought iMessage to Android
- Jun. 16th 2016 2:49 pm PT
Prior to WWDC, a report emerged claiming that Apple would at long last unveil iMessage for Android. Seeing how Apple had made its streaming music service available on Android, many found this report to be somewhat plausible. As you're probably aware of by now, however, iMessage for Android was nowhere to be found at WWDC this week. Now, we've gotten a little bit of insight into Apple's reasoning for not bringing its messaging service to Google's smartphone platform…
In his weekly column on The Verge, Walt Mossberg notes of a conversation he had with a "senior Apple executive" regarding the company bringing iMessage to Android. Essentially, what the Apple executive said is that the company has no driving reason to bring iMessage to Android and take it away as a selling point of iOS.
The executive explained that, because there are over 1 billion active devices, iOS users provide a "large enough data set" for any artificial intelligence initiatives that Apple may be working on. So, there's no need for Apple to want a larger dataset of users using iMessage at this point in time.
Additionally, the unnamed executive said that by having a strong service like iMessage available only on iOS and macOS, Apple is driving sales of its hardware. Again, this makes logical sense as there are certainly people out there who have purchased an iPhone, iPad, or Mac purely because they wanted iMessage.
When I asked a senior Apple executive why iMessage wasn't being expanded to other platforms, he gave two answers. First, he said, Apple considers its own user base of 1 billion active devices to provide a large enough data set for any possible AI learning the company is working on. And, second, having a superior messaging platform that only worked on Apple devices would help sales of those devices — the company's classic (and successful) rationale for years.
One wrinkle in this logic, however, is Apple Music. Apple did bring its streaming music service to Android, but it's a different type of scenario in my opinion. Apple needs to make sure that its streaming music platform is reaching the same size audience as competing services like Spotify. The biggest reason for this is that it's a negotiating tool when working with artists and labels. If an artist/label is looking to make a song or album release exclusive and they're considering Spotify and Apple Music, then it's important that Apple the same reach as Spotify in terms of users and potential users. That's not the case with iMessage.
While some Android users are likely upset that iMessage isn't coming to their smartphone anytime soon, iOS users are getting a host of new features with iOS 10 this fall, including a GIF keyboard, new message sending effects, and much more.
Apple was founded by Steve Jobs and Steve Wozniak in 1976. Today, it's considered one of the 'Big Tech' technology companies, alongside Amazon, Google, Microsoft, and Facebook.
iMessage Android


Hotel Carmen at NVC, Pastrana St; +63 36 268 8880. Basic lodgings located in the heart of the city.
Marzon Hotel Kalibo, Sta. Monica, Andagao; +63 36 268 2188; www.marzonhotelkalibo.com. This clean and comfortable hotel is just a ten-minute drive away from the airport, making it ideal for travelers in transit.
RB Lodge, Pastrana St corner N. Roldan St; facebook.com/RBLodgeKalibo. A pleasant budget hotel with rates starting at PHP300, depending on room availability.
Aquafresh Manokan, Osmeña St. Order the resaurant's famous chicken inasal, a juicy grilled chicken dish that's best eaten with your hands.
Grande Royale Restaurant, Jaime Cardinal Sin Ave; +63 998 574 7745. Order the seafood platter, which comes with grilled fish, squid, clams and shrimp, doused with garlic lemon butter sauce.
Hernani's Mix n' Match, L. Barrios St; +63 36 268 4240; facebook.com/hernanismixnmatch.bar. Fill your belly with affordable yet tasty fare, such as baby back ribs.
Kitty's Kitchen, J. Rizal St; +63 36 268 9444. A homegrown restaurant best known for its BBQ ribs.
Latte Coffee Café, Quezon Ave Extension (Jaime Cardinal Sin Ave), Andagao; +63 36 268 9026. Enjoy coffee, waffles and an array of superb cakes at this cozy café. There's also savory fare to be had, like sizzling bulalo and baby back ribs.
Niño's Ihaw-Ihaw Restaurant, Bulwang, Numancia; +63 36 268 1198. Have your fill of local cuisine, including blue marlin and spicy shrimp, at this popular restaurant.
Ramboy's, Toting Reyes St; +63 36 262 8327. Its famed liempo (pork belly) is unapologetically crispy and juicy.
Residence River Ihaw-Ihaw Resto Bar, New Washington, Tambak; +63 947 530 7875. Catch your own fish and then cook it at this popular eatery.
Saylo Cuisine, Magno Bldg, Quezon Ave Extension (Jaime Cardinal Sin Ave), Andagao; +63 36 268 6800; facebook.com/saylo.kalibo. Enjoy rib-sticking Aklanon delicacies like binakol (chicken soup) and inubarang manok (coconut-simmered chicken).
Ati-atihan Festival. A colorful street celebration held on the third Sunday of every January, in honor of the Santo Niño (Infant Jesus). Smear yourself in soot and dance to pounding music — it's a religious experience that is anything but somber.
Bakhawan Eco-Park. A 220-hectare mangrove forest and research center with trails that open into stunning views of the sea. Use bamboo rafts to get to the sandbar, where you can picnic in huts. Kayak rentals are also available.
Brgy Tangalan. Here, you'll find natural attractions like Jawili Falls, Jawili Beach and the beautiful Agfa Wave Rock Formations — a terraced rock face sculpted by wave action. It's around a 30-minute drive from the city.
Dela Cruz House of Piña, 81 New Buswang; +63 36 262 3267. Shop for high-quality piña fabrics, which are made from the leaves of the pineapple plant.
Finds Museum, Osmeña Ave, N Capitol Subdivision; +63 36 268 3907; facebook.com/FindsMuseum. This fine-arts museum near the Aklan Provincial Capitol houses a large collection of Asian antiques, European and American paintings (featuring Picasso and Pollock), First World stamps, jewelry, and more.
Kalibo Cathedral, Martelino St; +63 36 262 4246. Get in touch with your spiritual side at this cathedral, which was originally built in 1826.
Museo it Akean, Martelino St; +63 36 268 9260. Also known as Museo de Aklan, this downtown museum is the perfect place to learn more about the province and its rich history.
Sampaguita Gardens Resort, 1 Sampaguita Ave, New Washington; +63 36 264 3422; www.sampaguitagardensresort.weebly.com. Feel the holiday spirit every day at this resort, which features a Christmas store that's open all year round — the first of its kind in the Philippines.
Tigayon Hill and Caves. Explore the intriguing rock formations of one of Kalibo's newest tourist spots.


text:
Board and Commission Meetings
File #: 21-2020 Version: 1 Name:
Type: Evening Public Hearing/Appeal Status: Agenda Ready
File created: 2/7/2020 In control: CITY COUNCIL
On agenda: 4/21/2020 Final action:
Title: Transition to District-Based Elections for Councilmembers
Attachments: 1. ATCH 1 - Plan A Draft Map, 2. ATCH 2 - Plan B Draft Map, 3. ATCH 3 - Plan C Draft Map, 4. ATCH 4 - Plan D Draft Map, 5. ATCH 5 - Ordinance with EX A, 6. ATCH 6 - Public Correspondence, Draft Map Submissions & COIs
3/17/2020 1 CITY COUNCIL Not available Meeting details Not available
To:	Honorable Mayor and Members of City Council
From:	Tiffany Carranza, City Clerk
Prepared By:	Caitlin Saldanha, Deputy City Clerk
Transition to District-Based Elections for Councilmembers
RECOMMENDED ACTION:
(1) After receiving a presentation from City staff and the City's consulting demographer, invite public input regarding draft district boundary maps, the proposed sequence of elections of Councilmembers, and an ordinance to establish district-based elections for Councilmembers.
(2) Provide direction to staff to finalize the district boundary map.
(3) Provide direction to staff to finalize the sequence of elections of Councilmembers.
(4) Introduce an ordinance establishing district-based elections for Councilmembers by amending Napa Municipal Code Title 1 to add a new Chapter 1.10 ("District-Based Elections"), and approving the district boundary map and sequence of elections for Councilmembers, to be brought back to City Council for additional public input at a public hearing on April 28, 2020, and consideration of final adoption at a public hearing on May 5, 2020.
The City of Napa is in the process of transitioning from the current at-large election system, to a district-based election system for Councilmembers. Under the at-large system, the incumbent members of (and future candidates for) the City Council may reside anywhere in the City limits. Under a district-based system, the City will be divided into four separate geographical districts, and the voters residing in each district will vote for one Councilmember who also resides in that district. The office of the Mayor will remain a separate office and be directly elected by the voters citywide.
This transition process is in response to a petition letter received by the City on January 2, 2020. On February 11, 2020, the City Council adopted a Resolution of Intent (R2020-017) which declared the City's intent to transition from at-large ...
Click here for full text
Staff Reports with Details
Staff Reports Details (With Text)


In the always entertaining gift exchange between heads of state, Queen Elizabeth presented Chinese President Xi Jinping with a hand-tooled edition of Shakespeare's sonnets, Xi responded by giving the Queen two of his wife's albums.
Of course, before she was China's first lady, Peng Liyuan was a famous folk singer, adored by millions. We have no doubt that the Queen got the better of the trade and will be listening to those records every night before she sleeps and every morning after she wakes up. One Peng Liyuan album is simply not enough.
We have to assume that Xi totally spaced on buying the Queen a gift and had to drop by a Xinhua Bookstore on the way to the airport.
Xi also threw in a 1-meter-long embroidery, a China plate, a wooden sculpture and a book of stamps. Gee whiz, thanks!
Peng also received a pair of Royal Crown Derby candlesticks from the Queen and the couple were gifted a pair of silver-framed photographs of the Queen and the Duke of Edinburgh. Now, where are they gonna put those?
Final verdict? Does these top Putin's gift to Xi of a Russian-made smartphone? Yup.
The gift-giving followed a private lunch between the two leaders who also enjoyed a magic carriage ride together to Buckingham Palace.
XJP takes a magic carriage ride to Buckingham with the Queen.
Later that night, Xi and his better half classed up the palace during a state dinner. Between that time the Chinese president gave a speech.


text:
Linear Algebra/Linear Independence
< Linear Algebra
← Subspaces and Spanning sets Linear Independence Definition and Examples of Linear Independence →
The prior section shows that a vector space can be understood as an unrestricted linear combination of some of its elements— that is, as a span. For example, the space of linear polynomials { a + b x | a , b ∈ R } {\displaystyle \{a+bx\,{\big |}\,a,b\in \mathbb {R} \}} is spanned by the set { 1 , x } {\displaystyle \{1,x\}} . The prior section also showed that a space can have many sets that span it. The space of linear polynomials is also spanned by { 1 , 2 x } {\displaystyle \{1,2x\}} and { 1 , x , 2 x } {\displaystyle \{1,x,2x\}} .
At the end of that section we described some spanning sets as "minimal", but we never precisely defined that word. We could take "minimal" to mean one of two things. We could mean that a spanning set is minimal if it contains the smallest number of members of any set with the same span. With this meaning { 1 , x , 2 x } {\displaystyle \{1,x,2x\}} is not minimal because it has one member more than the other two. Or we could mean that a spanning set is minimal when it has no elements that can be removed without changing the span. Under this meaning { 1 , x , 2 x } {\displaystyle \{1,x,2x\}} is not minimal because removing the 2 x {\displaystyle 2x} and getting { 1 , x } {\displaystyle \{1,x\}} leaves the span unchanged.
The first sense of minimality appears to be a global requirement, in that to check if a spanning set is minimal we seemingly must look at all the spanning sets of a subspace and find one with the least number of elements. The second sense of minimality is local in that we need to look only at the set under discussion and consider the span with and without various elements. For instance, using the second sense, we could compare the span of { 1 , x , 2 x } {\displaystyle \{1,x,2x\}} with the span of { 1 , x } {\displaystyle \{1,x\}} and note that the 2 x {\displaystyle 2x} is a "repeat" in that its removal doesn't shrink the span.
In this section we will use the second sense of "minimal spanning set" because of this technical convenience. However, the most important result of this book is that the two senses coincide; we will prove that in the section after this one.
Retrieved from "https://en.wikibooks.org/w/index.php?title=Linear_Algebra/Linear_Independence&oldid=1807431"
Book:Linear Algebra


text:
Cornerstone City Menu
A Street Pastor is a Church leader/minister or member with a concern for society
YOU MAY ALSO FIND HELPFUL
MEDWAY STREET PASTORS WEBSITE
WHAT IS A STREET PASTOR?
A Street Pastor is a Church leader/minister or member with a concern for society - in particular young people who feel themselves to be excluded and marginalised - and who is willing to engage people where they are, in terms of their thinking (i.e. their perspective of life) and location (i.e. where they hang out - be it on the streets, in the pubs and clubs or at parties etc).
Street Pastors will also be willing to work with fellow activists, church and community leaders, and with agencies and projects, both statutory and voluntary, to look at collaborative ways of working on issues affecting youth, and initiatives that will build trust between them and the Street Pastors.
As the Street Pastor gets to know people in the community he/she will find out their needs are and what can be done to help. A presence of Street Pastors will earn credibility in the community, so that people know that the Church is there for them in a practical way. The role is not about preaching heaven and hell, but one of listening, caring and helping - working in an unconditional way
To be a Street Pastor you need to be over 18 (no upper age limit), a church member and able to commit to our training programme. Each Street Pastor team consists of at least three groups of four, each of which will work a minimum of one night a month, usually from 10pm to around 4am.
To get involved with Medway Street Pastors or for more information visit their website via the link below.
#streetpastors
All the latest news, information & events
Explore our library of podcasts
Visit the Cornerstone City Church YouTube channel
Weekly webmail
View & subscribe to the Cornerstone City Church newsletter.
View in new window


New 27 Toyota Innova Crysta MPVs will be a part of the new Special Transport Enforcement Cars that will check and monitor the emission from vehicles on the spot.
In a bid to curb air pollution, the government is all set to roll out Special Transport Enforcement Cars that will check and monitor the emission from vehicles on the spot. This initiative is headed by the Secretary Power and Commissioner of Transport Department which will see 27 Toyota Innova Crysta MPVs plying on Delhi roads with the real-time emission monitoring system. Currently, as per Delhi Traffic Police, any vehicle without a valid PUC certificate is eligible for a fine under section 115 CMVR/ 190(2) MV Act to up to Rs 2000 and the car can also be compoundable.
Varsha Joshi, IAS, Secretary Power & Commissioner of Transport, GNCT Delhi tweeted said, "Coming soon on a road near you- 27 of these gorgeous new Transport Enforcement vehicles, substantially adding to our capacity. Admire them, but make sure you don't get hauled up by them for no PUC or visible pollution! Get a servicing done and your PUC renewed, if needed, today!"
These specially designed Toyota Innova Crysta will further boost the team to crackdown against heavy pollution vehicles and many old diesel-powered cars and SUVs will be the first to face a charge for emitting pollution. Many did question why to use a vehicle made by Japanese automaker against the likes of Force Motors, Tata Motors and Mahindra. As much as the Toyota Innova Crysta is made in India the Twiiteratis just needed a reason to argue just for the sake of it against Varsha Joshi. She further said that "Be that as it may, we don't intend to get shamed, we intend to improve pollution compliance within Delhi, for which the cost of acquiring these is a pittance."
Varsha's goal is also to improve the last mile connectivity and did ask Anand Mahindra for a low floor, disabled friendly small electric minibus/ maxi-cab vehicles (12 seaters) for last mile connectivity in Delhi!
To this Anand Mahindra did suggest the Mahindra e-Supro electric offering as the last-mile connectivity solution. Varsha further wants the e-Supro to be disabled friendly and also small-operator friendly with company-led financing or buyback schemes. The new Transport Enforcement Vehicles will further keep the rising vehicle pollution in check and on the spot fine will ensure everyone opting for a PUC check immediately.
Even a cursory walk through the Joda Phatak locality of Amritsar reveals that the death of 59 people during the Ram Lila revelries on Friday evening was not the result of a sudden mishap. It seems more like an obvious outcome of decades of mismanagement and apathy towards how festivities in this part of the holy city are organised.
The Ram Lila was staged this week—like it has been for at least 14 years—not on an open ground but within the four-walled compound of a rustic dhobhi ghat. This ghat, overrun with stone slabs and water channels does have a small grassy compound, but it can barely accommodate 2,000 people. Yet, the organisers of this year's Ram Lila were given permission to host a 20,000-strong gathering by local authorities.
Not just that, the organisers seem to have gone all out to attract attention to their event, which is one of the at least ten Ram Lilas in town. Plush, multi-coloured posters with details of the exact location and the planned festivities have been put up all over the area by the organisers. They now serve as macabre reminder of how badly things went for those that attended.
The ghat at Joda Phatak is fenced in by a concrete wall on all sides. It opens up from a single large entry gate to the east, facing the busy Golden Avenue street and from a barely three-feet wide opening on the south that is not motorable. To the south of the ghat, beyond a perimeter wall that is five feet high, lies a low-lying grassy strip of land. Along this grassy strip runs a slightly elevated three-track railway line, resting on a bed of stone. And beyond these fateful tracks is a massive residential area—a slum populated by working class Amritsaris and thousands of migrants from some of the poorest districts of Uttar Pradesh and Bihar.
While Punjab chief minister Amarinder Singh set up a magisterial inquiry into how a train could have smashed into people attending a Ram Lila event, locals unwaveringly blame Sidhu for this crisis. "Sidhu came to the Ravana-burning more than one-and-a-half hours late. The time to consign Ravana to flames should be at dusk, around 6 pm, but she showed up at well after 7. It was too dark for us to notice any train coming our way at that hour," said Hemant Rai, a local car trader, who was present at yesterday's fiasco and helped ferry injured to hospitals.
Every year (except 2017, when the Ram Lila was not organised due to a local leader's death), thousands gather at this dhobhi ghat for Dussehra celebrations. Delicacies from Uttar Pradesh and Bihar are sold from pushcarts by vendors who know that they will get a large number of buyers on this day. This year, the organisers set up at least one (possibly two) large LED TV screens, locals said. These screens were raised to the height of several meters, and one of them faced the railway tracks.
This was done by the organisers because they knew that crowds far in excess of the capacity of the dhobhi ghat would gather. On the LED screens, they would watch the festival whilst standing or sitting on the tracks, which being slightly raised also allowed a peep into what was happening within the compound. Ramesh Kumar, who ekes put a living as a bronze worker, and is now recuperating from severe injuries at the Amritsar Civil Hospital, said "the whole world was on the railway tracks" on Friday after 6 p, as they "watched the LED screen blare out Punjabi numbers." There was no way to watch that screen except from on the tracks, and so people stayed on.
A team of district officials inspected the venue before the event but they limited their investigation to how the stage for VIPs was set up. They paid no attention to the well-known fact that people were expected to gather beyond the walls of the ghat and watch the show from the railway tracks.
As is customary, children insisted on seeing Ravana go down in flames, and parents—both Sikh and migrant Hindu workers—brought them to Joda Phatak in large numbers. Since migrant workers often live far from their families, who are in very distant parts of the country, these attendees showed a particular inclination to record the festivities using their mobile phones.
They said they wanted to share the videos of Ram Lila and Ravana's effigy burning in Punjab with their relatives back home. This simple act of trying to forge a connection with people far away compounded their tragedy, for they were distracted from the danger barrelling toward them at breakneck speed—a train would pummel into them not even an hour later and they would be caught unawares.
Around 7:40 pm, right after Ravana's effigy was set alight, crackers stuffed inside the idol also burst into flame and sped into the air as rockets of fire. The people who had been watching the events from outside the perimeter wall shifted further south to avoid these projectiles; they either strayed further on to the tracks or got much closer to those who were already on the tracks.
This is right after two other trains, both headed north, (toward Jalandhar) went past them in quick succession and on separate tracks. Both these trains went by painfully slowly, locals said. This slowing down of trains, they said, is the usual practice, for authorities know that Dussehra is celebrated in these parts every year. The crowd easily dodged these two trains but by the end of their manoeuvres more people ended up on one of the three train tracks: the one closest to the ghat's perimeter wall. Now, a third train was coming hurtling down from the north, headed toward Amritsar city, unbeknownst to these celebratory crowds.
"This train was coming at super-fast speed. By now Ravana was burning and crackers were flying about and everything was so loud that we had put our fingers in our ears. That is why we could neither see the train nor hear it," said Devinder Singh, a young fuel station employee who lives in a part of the slum beyond the dhobhi ghat, known as Krishna Nagar. Scores had come to the tracks to watch the effigy burn on their bicycles through the narrow lanes of Krishna Nagar. "They must have died or were injured because they never returned to pick up their bicycles from our colony," Devinder said.
This could also be why people heard no horn sounded by the train's driver: the festivities get more and more raucous every year, and the crowds bigger too. Many who have ended up in hospital after the train ploughed through them say they were mesmerised by the attractions at the fair: not just the effigy on fire but the crackers and the "famous Punjabi singer" who had been brought to fill the time before the chief guest—the much-delayed Sidhu—arrived.
Chief Minister Amarinder Singh paid a visit to the spot of the tragedy on Saturday afternoon, but he was met with a restive and aggressive crowd that had to be controlled with lathi-charge. They kept shouting slogans against the government: saying they didn't believe a train would come rushing at them: they had grown accustomed to trains slowing down on Dussehra. Earlier, while ordering a magisterial inquiry into the incident Amarinder said he would not want to comment on whether the venue was granted permission or not, nor would he comment on the Indian Railways claim that the incident was not an accident but an act of trespass. On this and other questions, Amarinder said the magisterial inquiry of four weeks would have to be the final answer.
Yet, it wasn't just the train that mowed down people Friday evening. Locals and patients in both Guru Tej Bahadur Hospital and Amritsar Civil Hospital said they lost their near and dear ones in the ensuing stampede. Sandeep (Kour), a Punjabi woman, was among those injured in this stampede, which involved bodies of those who came under the train's wheels being flung on to those who were alive and distant from the tracks. She lost her father, a son and a daughter in this crush, she said.
Jaspreet Singh and Shailendra Singh, DSP and SP rank Punjab Police officials on duty at Amritsar Civil Hospital said the train driver cannot be blamed because he got a green signal at a checkpoint just a few hundred meters from the perimeter wall of the dhobhi ghat. "Even if the signal wasn't given, that doesn't give people the right to walk on the railway tracks, does it?" asked Jaspreet.
So far, 113 injured have come into the civil hospital: none have been discharged. Thirty-nine have died, of whom three remain unidentified. At the GTB Hospital, 27 injured have been brought and 19 have died. Some injured have been shifted to other hospitals.
This guy turns tires to sandals.


Action-adventure superstar Arnold Schwarzenegger bursts through the screen as a larger-than-life movie hero in this nonstop adventure from acclaimed director John McTiernan (Predator, Die Hard).
Critics Consensus: Last Action Hero has most of the right ingredients for a big-budget action spoof, but its scattershot tone and uneven structure only add up to a confused, chaotic mess.
Last Action Hero loses control of itself.
Feels like a farewell, of sorts, to Arnold.
There is a lot of action in Last Action Hero, but the underlying story never ever quite works.
The pulse-pounding, sizzling pull of a Die Hard is absent.
The divergent puzzle pieces do not often fit together terribly well, in spite of their potential.
Really would work if it ever really let audiences in what it was trying to accomplish.
Parents need to know that this spoof/critique of action films has itself an excessive amount of violence, explosions, and killings. While kids may love this, the sheer number of people who are killed or plotted to be killed (at least 15) make it too much for younger kids. Jack's son is killed and daughter kidnapped, and Danny nearly dies as well. Jack is shot and nearly dies, bubbling up blood from his mouth. Also, several characters smoke.


text:
House Director Job Opportunities
NHC Board
Featured House: Alpha Beta - University of Illinois
Featured House: Alpha Gamma - University of Alabama
Featured House: Epsilon Nu - Missouri State University
Featured House: Kappa - University of Washington
Featured House: Omicron Gamma - Ohio University
Featured House: Omicron Lambda - North Carolina State University
The Delta Zeta House: A Home Across Generations
By: Maggie Old, Omicron Gamma-Ohio, Digital Communications Intern
When you think of "home," where does your mind take you? A person? A place? For Delta Zetas, their chapter houses and suites become "home" to them, and for more than just the physical location.
Madison King and her mother, Janice Floyd King, share the same home in Delta Zeta, the Omicron Gamma Chapter at Ohio University. To chapter members, the house is better known as "Big Blue" or "55", for the house's address on Mill Street in Athens, Ohio.
In 1989, Janice was a founding member of the chapter. Within two years, Delta Zeta finalized plans for a new four-story chapter house, designed to be a home away from home for members! The house was completed and ready for occupancy in 1994. The house was built to be a place for all past, present and future generations of Delta Zetas. One of those future members was Janice's daughter, Madison.
Madison joined the chapter in 2019. Her mom was at her Initiation Ceremony and shared in that special moment. "I wish I could fully express how much it meant to me to have my mom at my Initiation. I was overwhelmed with emotion because I knew how much DZ meant to her. It brought the two of us closer, and I know she was so proud to see the current collegiate women and to visit the house," Madison said. She was able to experience the sisterhood that her mom and now sister helped build, both as a structure and as an organization. Madison said, "I remember the first time I saw the chapter house. My mom couldn't stop crying. When I walked through the doors, I was instantly welcomed."
Both Gloria Van Reeth, the current House Director, and active members today take care of the property to always be ready and welcoming. Of all the chapter houses on Ohio University's campus, Delta Zeta's is also the most accessible. With ramps, appropriate doorframes, accessible bathrooms and bedrooms and an elevator, the Omicron Gamma Chapter house is a modern structure that allows anyone with a physical disability to access it easily.
You will feel the sisterhood as soon as you step through the doors of "Big Blue." The hallways and stairwells are lined with composites, awards and certificates, pictures of sisters throughout the years, and so much more. This connects members across decades who have lived there, whether in 1994 or 2021. It reassures members that their friendships will not end at graduation but instead last a lifetime. The women who have, and will continue to, live in the chapter house will share memories, laughs and experiences that will last them a lifetime.
"When I met the women of DZ, I knew this was exactly where I needed to be. They accept you for who you are, and they don't turn you away. I have never met a more genuine group of women, and now they're with me forever." Madison explained.
Janice shared her experience as a founding member "I remember when Delta Zeta was chosen and how exciting it was to become a member. I instantly met amazing women that became lifelong friends. I learned a lot about commitment, sisterhood and what it means to have over fifty ladies who you can count on." She shared her experience with the chapter house as well, saying, "I think having a dedicated space like a house to recruit, have chapter meetings and hang out would provide any sorority sister a more meaningful experience. It's hard to put into words what I felt when Madison joined Delta Zeta. It brings a joyful tear to my eye."
Looking at a sketch of the future house in 1991, it might look like a simple drawing of an attractive building. But the women who helped lay the foundation for the Omicron Gamma Chapter knew that it was so much more. They developed a home away from home. The memories and experiences sisters have together show the strong bond of sisterhood that can be created through a shared home, or space, and a shared sisterhood.
Service & Philanthropy
Recommend a Member
News from HQ
202 East Church Street
Oxford, Ohio 45056


Bought GB WT5 last season, it worked great until about a week ago. I have reset & also emergency rebooted. The watch charges normally & finds the satellite setting the time... but it wont find a golf course. Tried updating but received error messages even after dl'ing drivers etc..
Anyone have this problem? How do I resolve these issues. Called tech support, they havent had the courtesy to help with these issues.
Right click on start and select "open windows explorer"
On the left side of the new window, select "computer"
On the right side of the new window, right click on your WT5 and select "properties"
Run chkdsk on those files and select automatic fix.
Go to golfbuddy website and download GB3 manager.
If you can sync to the manager program, you can reload or update the firmware and all the course information.
Once the files are good, it should be able to lock satellites to a course loaded on the WT5.


text:
Home » Are agency employees protected from unfair dismissal?
Are agency employees protected from unfair dismissal?
by The FindLaw Team
According to the Australian Bureau of Statistics (ABS), five percent of Australian employees currently in the workforce are labour hire employees, and for the most part, will be considered as casual employees. Because most agency employees will hold a casual status, they'll generally have the same benefits and liabilities as their casual cohorts. So with that being said, labour hire employees will probably be no different from other types of employees in that they'll hold the same concerns and fears in regards to matters such as job security, however, unlike part-time or full-time employees, labour hire workers have limited recourse in the event of an unfair dismissal. So the inquiry that needs to be asked is: What options are available to a labour hire/agency worker in the event of an unfair dismissal? The question is worth exploring especially when we take into account the limited rights available to casual employees if they wish to initiate an unfair dismissal claim under the Fair Work Act 2009 (Cth) (the FWA).
The common law position
If a labour hire employee is not offered any further work by the labour hire agency, this may constitute a 'dismissal', although, industrial awards and instruments found within state legislation may make special provisions in regards to notice and other such requirements. However, in the absence of such provisions, we can look to case law for some guidance in regards to dismissal of a labour hire employee.
In Nguyen v A-N-T Contract Packers Pty Ltd (t/as A-N-T Personnel) (2003) 128 IR 241, the Industrial Relations Commission of New South Wales (the Commission) had to determine whether the applicant who made a claim for unfair dismissal was a labour hire firm employee or an employee of the host company.
The applicant in Nguyen had worked exclusively for the host company for two and a half years and it was later found that the host company had terminated the applicant's employment after she became pregnant – which was in breach of anti-discrimination legislation. The agency argued that the applicant was not 'dismissed' because she was still on their books, leading to the claim by the host company that an action of unfair dismissal was not available because the applicant was an employee of the labour hire agency.
McKenna C who was presiding over the matter, held that the host company was indeed the employer of the applicant, and that the dismissal was harsh, unreasonable and unjust, therefore, the applicant had an available claim for unfair dismissal. The Commissioner in Nguyen accepted the views of the South Australian Commission that a "casual employee deprived of employment from time-to-time according to a regular roster arrangement may well…reasonably be said to have had his services dispensed with – that constitutes a dismissal."
The Fair Work Act
As noted in the introduction, a labour hire employee may have some difficulty in making an unfair dismissal claim under ss 382 – 384. For national system employees, the person must have been employed for the minimum period of employment, and have been employed on a regular and systematic basis for six months, or if the employer is a small business, the minimum period of employment is 12 months. Furthermore, the labour hire employee must have one or more of the following be applicable in order to make a claim of unfair dismissal:
the employee must be covered by a modern award or an enterprise agreement; or
their earnings must be below the high income threshold which at the time of writing, $138, 900.
Employment Law - Worker Perspective
Employment Law - Employer Perspective


We are looking for a graphic designer/art worker for a few weeks to help establishing a new brand to existing printed documents and other branded materials that could also include some digital asset creation as well. The ideal candidate can work comfortably in Adobe InDesign, Photoshop and Sketch.
Please send your application with CV/ portfolio/ rates/ availability to recruiter Anna Persson at anna@nucreatives.com. Mark it 'GD London'.


BEST CONDO'S layout: 2 of its bedrooms face the oversized terrace, and offer gorgeous ocean views. 4TH FLOOR, TOWER 1 (best and more private view - unblocked). 3 bd-2 bth. UNIQUE LUXURIOUS UPGRADES: beautiful bar with additional built in cabinets, granite couter top and wine cooler included, great Weber built in BBQ grill and sink with storage already in place with high end finishes, screens for sliding Doors and Windows, laundry room with laundry sink conveniently located, and extended countertop at the kitchen. Sold by Lynn Gutierrez.