text:
//---------------------------------------------------------------------
// <copyright file="MediaTypeUtils.cs" company="Microsoft">
//      Copyright (C) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
// </copyright>
//---------------------------------------------------------------------

namespace Microsoft.OData.Core
{
    #region Namespaces
    using System;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Linq;
    using System.Text;
    #endregion Namespaces

    ///
    /// Class with utility methods to work with media types.
    ///
    internal static class MediaTypeUtils
    {
        /// An array of all the supported payload kinds.
        private static readonly ODataPayloadKind[] allSupportedPayloadKinds = new ODataPayloadKind[]
        {
            ODataPayloadKind.Feed,
            ODataPayloadKind.Entry,
            ODataPayloadKind.Property,
            ODataPayloadKind.MetadataDocument,
            ODataPayloadKind.ServiceDocument,
            ODataPayloadKind.Value,
            ODataPayloadKind.BinaryValue,
            ODataPayloadKind.Collection,
            ODataPayloadKind.EntityReferenceLinks,
            ODataPayloadKind.EntityReferenceLink,
            ODataPayloadKind.Batch,
            ODataPayloadKind.Error,
            ODataPayloadKind.Parameter,
            ODataPayloadKind.IndividualProperty,
            ODataPayloadKind.Delta,
            ODataPayloadKind.Asynchronous
        };

        /// UTF-8 encoding, without the BOM preamble.
        /// <remarks>
        /// While a BOM preamble on UTF8 is generally benign, it seems that some MIME handlers under IE6 will not
        /// process the payload correctly when included.
        ///
        /// Because the data service should include the encoding as part of the Content-Type in the response,
        /// there should be no ambiguity as to what encoding is being used.
        ///
        /// For further information, see http://www.unicode.org/faq/utf_bom.html#BOM.
        /// </remarks>
        private static readonly UTF8Encoding encodingUtf8NoPreamble = new UTF8Encoding(false, true);

        ///
        /// Max size to cache match info.
        ///
        private const int MatchInfoCacheMaxSize = 1024;

        ///
        /// Concurrent cache to cache match info.
        ///
        private static MatchInfoConcurrentCache MatchInfoCache = new MatchInfoConcurrentCache(MatchInfoCacheMaxSize);

        /// UTF-8 encoding, without the BOM preamble.
        /// <remarks>
        /// While a BOM preamble on UTF8 is generally benign, it seems that some MIME handlers under IE6 will not
        /// process the payload correctly when included.
        ///
        /// Because the data service should include the encoding as part of the Content-Type in the response,
        /// there should be no ambiguity as to what encoding is being used.
        ///
        /// For further information, see http://www.unicode.org/faq/utf_bom.html#BOM.
        /// </remarks>
        internal static UTF8Encoding EncodingUtf8NoPreamble
        {
            get
            {
                return encodingUtf8NoPreamble;
            }
        }

        /// Encoding to fall back to an appropriate encoding is not available.
        internal static Encoding FallbackEncoding
        {
            get
            {
                return MediaTypeUtils.EncodingUtf8NoPreamble;
            }
        }

        /// Encoding implied by an unspecified encoding value.
        /// <remarks>See http://tools.ietf.org/html/rfc2616#section-3.4.1 for details.</remarks>
        internal static Encoding MissingEncoding
        {
            get
            {
#if !ORCAS
                return Encoding.UTF8;
#else
                return Encoding.GetEncoding("ISO-8859-1", new EncoderExceptionFallback(), new DecoderExceptionFallback());
#endif
            }
        }

        ///
        /// Given the Accept and the Accept-Charset headers of the request message computes the media type, encoding and <see cref="ODataFormat"/>
        /// to be used for the response message.
        ///
        /// <param name="settings">The message writer settings to use for serializing the response payload.</param>
        /// <param name="payloadKind">The kind of payload to be serialized as part of the response message.</param>
        /// <param name="mediaTypeResolver">The media type resolver to use when interpreting the content type.</param>
        /// <param name="mediaType">The media type to be used in the response message.</param>
        /// <param name="encoding">The encoding to be used in the response message.</param>
        /// <returns>The <see cref="ODataFormat"/> used when serializing the response.</returns>
        internal static ODataFormat GetContentTypeFromSettings(
            ODataMessageWriterSettings settings,
            ODataPayloadKind payloadKind,
            ODataMediaTypeResolver mediaTypeResolver,
            out ODataMediaType mediaType,
            out Encoding encoding)
        {
            Debug.Assert(settings != null, "settings != null");

            // compute format, media type and encoding
            ODataFormat format;

            // get the supported and default media types for the specified payload kind
            IList<ODataMediaTypeFormat> supportedMediaTypes = mediaTypeResolver.GetMediaTypeFormats(payloadKind).ToList();
            if (supportedMediaTypes == null || supportedMediaTypes.Count == 0)
            {
                throw new ODataContentTypeException(Strings.MediaTypeUtils_DidNotFindMatchingMediaType(null, settings.AcceptableMediaTypes));
            }

            if (settings.UseFormat == true)
            {
                Debug.Assert(settings.AcceptableMediaTypes == null, "settings.AcceptableMediaTypes == null");
                Debug.Assert(settings.AcceptableCharsets == null, "settings.AcceptableCharsets == null");

                mediaType = GetDefaultMediaType(supportedMediaTypes, settings.Format, out format);

                // NOTE the default media types don't have any parameters (in particular no 'charset' parameters)
                encoding = mediaType.SelectEncoding();
            }
            else
            {
                // parse the accept header into its parts
                IList<KeyValuePair<ODataMediaType, string>> specifiedTypes = HttpUtils.MediaTypesFromString(settings.AcceptableMediaTypes);

                // Starting in V3 we replace all occurrences of application/json with application/json;odata.metadata=minimal
                // before handing the acceptable media types to the conneg code. This is necessary because for an accept
                // header 'application/json, we want to the result to be 'application/json;odata.metadata=minimal'
                ConvertApplicationJsonInAcceptableMediaTypes(specifiedTypes);

                ODataMediaTypeFormat selectedMediaTypeWithFormat;
                string specifiedCharset = null;
                if (specifiedTypes == null || specifiedTypes.Count == 0)
                {
                    selectedMediaTypeWithFormat = supportedMediaTypes[0];
                }
                else
                {
                    // match the specified media types against the supported/default ones and get the format
                    MediaTypeMatchInfo matchInfo = MatchMediaTypes(specifiedTypes.Select(kvp => kvp.Key), supportedMediaTypes.Select(smt => smt.MediaType).ToArray());
                    if (matchInfo == null)
                    {
                        // We're calling the ToArray here since not all platforms support the string.Join which takes IEnumerable.
                        string supportedTypesAsString = String.Join(", ", supportedMediaTypes.Select(mt => mt.MediaType.ToText()).ToArray());
                        throw new ODataContentTypeException(Strings.MediaTypeUtils_DidNotFindMatchingMediaType(supportedTypesAsString, settings.AcceptableMediaTypes));
                    }

                    selectedMediaTypeWithFormat = supportedMediaTypes[matchInfo.TargetTypeIndex];
                    specifiedCharset = specifiedTypes[matchInfo.SourceTypeIndex].Value;
                }

                format = selectedMediaTypeWithFormat.Format;
                mediaType = selectedMediaTypeWithFormat.MediaType;

                // If a charset was specified with the accept header, consider it for the encoding
                string acceptableCharsets = settings.AcceptableCharsets;
                if (specifiedCharset != null)
                {
                    acceptableCharsets = acceptableCharsets == null ? specifiedCharset : specifiedCharset + "," + acceptableCharsets;
                }

                encoding = GetEncoding(acceptableCharsets, payloadKind, mediaType, /*useDefaultEncoding*/ true);
            }

            return format;
        }

        ///
        /// Determine the <see cref="ODataFormat"/> to use for the given <paramref name="contentTypeHeader"/>. If no supported content type
        /// is found an exception is thrown.
        ///
        /// <param name="contentTypeHeader">The name of the content type to be checked.</param>
        /// <param name="supportedPayloadKinds">All possiblel kinds of payload that can be read with this content type.</param>
        /// <param name="mediaTypeResolver">The media type resolver to use when interpreting the content type.</param>
        /// <param name="mediaType">The media type parsed from the <paramref name="contentTypeHeader"/>.</param>
        /// <param name="encoding">The encoding from the content type or the default encoding for the <paramref name="mediaType" />.</param>
        /// <param name="selectedPayloadKind">
        /// The payload kind that was selected form the list of <paramref name="supportedPayloadKinds"/> for the
        /// specified <paramref name="contentTypeHeader"/>.
        /// </param>
        /// <param name="batchBoundary">The batch boundary read from the content type for batch payloads; otherwise null.</param>
        /// <returns>The <see cref="ODataFormat"/> for the <paramref name="contentTypeHeader"/>.</returns>
        internal static ODataFormat GetFormatFromContentType(
            string contentTypeHeader,
            ODataPayloadKind[] supportedPayloadKinds,
            ODataMediaTypeResolver mediaTypeResolver,
            out ODataMediaType mediaType,
            out Encoding encoding,
            out ODataPayloadKind selectedPayloadKind,
            out string batchBoundary)
        {
            Debug.Assert(!supportedPayloadKinds.Contains(ODataPayloadKind.Unsupported), "!supportedPayloadKinds.Contains(ODataPayloadKind.Unsupported)");

            ODataFormat format = GetFormatFromContentType(contentTypeHeader, supportedPayloadKinds, mediaTypeResolver, out mediaType, out encoding, out selectedPayloadKind);

            // for batch payloads, read the batch boundary from the content type header; this is the only
            // content type parameter we support (and that is required for batch payloads)
            if (selectedPayloadKind == ODataPayloadKind.Batch)
            {
                KeyValuePair<string, string> boundaryPair = default(KeyValuePair<string, string>);
                IEnumerable<KeyValuePair<string, string>> parameters = mediaType.Parameters;
                if (parameters != null)
                {
                    bool boundaryPairFound = false;
                    foreach (KeyValuePair<string, string> pair in parameters.Where(p => HttpUtils.CompareMediaTypeParameterNames(ODataConstants.HttpMultipartBoundary, p.Key)))
                    {
                        if (boundaryPairFound)
                        {
                            throw new ODataException(Strings.MediaTypeUtils_BoundaryMustBeSpecifiedForBatchPayloads(contentTypeHeader, ODataConstants.HttpMultipartBoundary));
                        }

                        boundaryPair = pair;
                        boundaryPairFound = true;
                    }
                }

                if (boundaryPair.Key == null)
                {
                    throw new ODataException(Strings.MediaTypeUtils_BoundaryMustBeSpecifiedForBatchPayloads(contentTypeHeader, ODataConstants.HttpMultipartBoundary));
                }

                batchBoundary = boundaryPair.Value;
                ValidationUtils.ValidateBoundaryString(batchBoundary);
            }
            else
            {
                batchBoundary = null;
            }

            return format;
        }

        ///
        /// Gets all payload kinds and their corresponding formats that match the specified content type header.
        ///
        /// <param name="contentTypeHeader">The content type header to get the payload kinds for.</param>
        /// <param name="mediaTypeResolver">The media type resolver to use when interpreting the content type.</param>
        /// <param name="contentType">The parsed content type as <see cref="ODataMediaType"/>.</param>
        /// <param name="encoding">The encoding from the content type or the default encoding from <see cref="ODataMediaType" />.</param>
        /// <returns>The list of payload kinds and formats supported for the specified <paramref name="contentTypeHeader"/>.</returns>
        internal static IList<ODataPayloadKindDetectionResult> GetPayloadKindsForContentType(string contentTypeHeader, ODataMediaTypeResolver mediaTypeResolver, out ODataMediaType contentType, out Encoding encoding)
        {
            Debug.Assert(!String.IsNullOrEmpty(contentTypeHeader), "Content-Type header must not be null or empty.");

            string charset;
            encoding = null;
            contentType = ParseContentType(contentTypeHeader, out charset);
            ODataMediaType[] targetTypes = new ODataMediaType[] { contentType };

            List<ODataPayloadKindDetectionResult> payloadKinds = new List<ODataPayloadKindDetectionResult>();

            IList<ODataMediaTypeFormat> mediaTypesForKind = null;
            for (int i = 0; i < allSupportedPayloadKinds.Length; ++i)
            {
                // get the supported and default media types for the current payload kind
                ODataPayloadKind payloadKind = allSupportedPayloadKinds[i];
                mediaTypesForKind = mediaTypeResolver.GetMediaTypeFormats(payloadKind).ToList();

                // match the specified media types against the supported/default ones
                // and get the format
                MediaTypeMatchInfo matchInfo = MatchMediaTypes(mediaTypesForKind.Select(smt => smt.MediaType), targetTypes);
                if (matchInfo != null)
                {
                    Debug.Assert(matchInfo.TargetTypeIndex == 0, "Invalid target type index detected.");
                    payloadKinds.Add(new ODataPayloadKindDetectionResult(payloadKind, mediaTypesForKind[matchInfo.SourceTypeIndex].Format));
                }
            }

            if (!String.IsNullOrEmpty(charset))
            {
                encoding = HttpUtils.GetEncodingFromCharsetName(charset);
            }

            return payloadKinds;
        }

        ///
        /// Checks whether two media types with subtypes (but without parameters) are equal.
        ///
        /// <param name="firstTypeAndSubtype">The first media type and subtype.</param>
        /// <param name="secondTypeAndSubtype">The second media type and subtype.</param>
        /// <returns>true if the <paramref name="firstTypeAndSubtype"/> is equal to <paramref name="secondTypeAndSubtype"/>; otherwise false.</returns>
        internal static bool MediaTypeAndSubtypeAreEqual(string firstTypeAndSubtype, string secondTypeAndSubtype)
        {
            ExceptionUtils.CheckArgumentNotNull(firstTypeAndSubtype, "firstTypeAndSubtype");
            ExceptionUtils.CheckArgumentNotNull(secondTypeAndSubtype, "secondTypeAndSubtype");

            return HttpUtils.CompareMediaTypeNames(firstTypeAndSubtype, secondTypeAndSubtype);
        }

        ///
        /// Checks whether a media type starts with the expected type and subtype.
        ///
        /// <param name="mediaType">The media type to check.</param>
        /// <param name="typeAndSubtype">The type and subtype the <paramref name="mediaType"/> should start with.</param>
        /// <returns>true if the <paramref name="mediaType"/> starts with <paramref name="typeAndSubtype"/>; otherwise false.</returns>
        internal static bool MediaTypeStartsWithTypeAndSubtype(string mediaType, string typeAndSubtype)
        {
            ExceptionUtils.CheckArgumentNotNull(mediaType, "mediaType");
            ExceptionUtils.CheckArgumentNotNull(typeAndSubtype, "typeAndSubtype");

            return mediaType.StartsWith(typeAndSubtype, StringComparison.OrdinalIgnoreCase);
        }

        ///
        /// Checks whether the specified media type has a parameter with the expected value.
        ///
        /// <param name="mediaType">The media type to check the parameters for.</param>
        /// <param name="parameterName">The name of the expected parameter.</param>
        /// <param name="parameterValue">The value of the expected parameter.</param>
        /// <returns>true if the <paramref name="mediaType"/> has a parameter called <paramref name="parameterName"/>
        /// with value <paramref name="parameterValue"/>; otherwise false.</returns>
        internal static bool MediaTypeHasParameterWithValue(this ODataMediaType mediaType, string parameterName, string parameterValue)
        {
            Debug.Assert(mediaType != null, "mediaType != null");
            Debug.Assert(parameterName != null, "parameterName != null");

            if (mediaType.Parameters == null)
            {
                return false;
            }

            return mediaType.Parameters.Any(p =>
                HttpUtils.CompareMediaTypeParameterNames(p.Key, parameterName) &&
                String.Compare(p.Value, parameterValue, StringComparison.OrdinalIgnoreCase) == 0);
        }

        ///
        /// Determines whether the media type has a 'streaming' parameter with the value 'true'.
        ///
        /// <param name="mediaType">The media type to check.</param>
        /// <returns>
        ///   <c>true</c> if  the media type has a 'streaming' parameter with the value 'true'; otherwise, <c>false</c>.
        /// </returns>
        internal static bool HasStreamingSetToTrue(this ODataMediaType mediaType)
        {
            return mediaType.MediaTypeHasParameterWithValue(MimeConstants.MimeStreamingParameterName, MimeConstants.MimeParameterValueTrue);
        }

        ///
        /// Determines whether the media type has a 'IEEE754Compatible' parameter with the value 'true'.
        ///
        /// <param name="mediaType">The media type to check</param>
        /// <returns>
        ///   <c>true</c> if  the media type has a 'IEEE754Compatible' parameter with the value 'true'; otherwise, <c>false</c>.
        /// </returns>
        internal static bool HasIeee754CompatibleSetToTrue(this ODataMediaType mediaType)
        {
            return mediaType.MediaTypeHasParameterWithValue(MimeConstants.MimeIeee754CompatibleParameterName, MimeConstants.MimeParameterValueTrue);
        }

        ///
        /// Checks for wildcard characters in the <see cref="ODataMediaType"/>.
        ///
        /// <param name="mediaType">The <see cref="ODataMediaType"/> to check.</param>
        internal static void CheckMediaTypeForWildCards(ODataMediaType mediaType)
        {
            Debug.Assert(mediaType != null, "mediaType != null");

            if (HttpUtils.CompareMediaTypeNames(MimeConstants.MimeStar, mediaType.Type) ||
                HttpUtils.CompareMediaTypeNames(MimeConstants.MimeStar, mediaType.SubType))
            {
                throw new ODataContentTypeException(Strings.ODataMessageReader_WildcardInContentType(mediaType.FullTypeName));
            }
        }

        ///
        /// JSONP - instead of writing 'application/json', we write 'text/javascript'. In all other ways we pretend it is JSON
        ///
        /// <param name="contentType">Original content-type value string.</param>
        /// <returns>New content-type value string.</returns>
        internal static string AlterContentTypeForJsonPadding(string contentType)
        {
            if (contentType.StartsWith(MimeConstants.MimeApplicationJson, StringComparison.OrdinalIgnoreCase))
            {
                return contentType.Remove(0, MimeConstants.MimeApplicationJson.Length).Insert(0, MimeConstants.TextJavaScript);
            }

            if (contentType.StartsWith(MimeConstants.MimeTextPlain, StringComparison.OrdinalIgnoreCase))
            {
                return contentType.Remove(0, MimeConstants.MimeTextPlain.Length).Insert(0, MimeConstants.TextJavaScript);
            }

            throw new ODataException(Strings.ODataMessageWriter_JsonPaddingOnInvalidContentType(contentType));
        }

        ///
        /// Determine the <see cref="ODataFormat"/> to use for the given <paramref name="contentTypeName"/>. If no supported content type
        /// is found an exception is thrown.
        ///
        /// <param name="contentTypeName">The name of the content type to be checked.</param>
        /// <param name="supportedPayloadKinds">All possiblel kinds of payload that can be read with this content type.</param>
        /// <param name="mediaTypeResolver">The media type resolver to use when interpreting the content type.</param>
        /// <param name="mediaType">The media type parsed from the <paramref name="contentTypeName"/>.</param>
        /// <param name="encoding">The encoding from the content type or the default encoding for the <paramref name="mediaType" />.</param>
        /// <param name="selectedPayloadKind">
        /// The payload kind that was selected form the list of <paramref name="supportedPayloadKinds"/> for the
        /// specified <paramref name="contentTypeName"/>.
        /// </param>
        /// <returns>The <see cref="ODataFormat"/> for the <paramref name="contentTypeName"/>.</returns>
        private static ODataFormat GetFormatFromContentType(string contentTypeName, ODataPayloadKind[] supportedPayloadKinds, ODataMediaTypeResolver mediaTypeResolver, out ODataMediaType mediaType, out Encoding encoding, out ODataPayloadKind selectedPayloadKind)
        {
            Debug.Assert(!supportedPayloadKinds.Contains(ODataPayloadKind.Unsupported), "!supportedPayloadKinds.Contains(ODataPayloadKind.Unsupported)");

            string charset;
            mediaType = ParseContentType(contentTypeName, out charset);

            IList<ODataMediaTypeFormat> supportedMediaTypes = null;
            for (int i = 0; i < supportedPayloadKinds.Length; ++i)
            {
                // get the supported and default media types for the current payload kind
                ODataPayloadKind supportedPayloadKind = supportedPayloadKinds[i];
                supportedMediaTypes = mediaTypeResolver.GetMediaTypeFormats(supportedPayloadKind).ToList();

                // match the specified media types against the supported/default ones
                // and get the format
                var cacheKey = new MatchInfoCacheKey(mediaTypeResolver, supportedPayloadKind, contentTypeName);
                MediaTypeMatchInfo matchInfo;

                if (!MatchInfoCache.TryGetValue(cacheKey, out matchInfo))
                {
                    matchInfo = MatchMediaTypes(supportedMediaTypes.Select(smt => smt.MediaType), new[] { mediaType });
                    MatchInfoCache.Add(cacheKey, matchInfo);
                }

                if (matchInfo != null)
                {
                    Debug.Assert(matchInfo.TargetTypeIndex == 0, "Invalid target type index detected.");
                    selectedPayloadKind = supportedPayloadKind;
                    encoding = GetEncoding(charset, selectedPayloadKind, mediaType, /*useDefaultEncoding*/ false);
                    return supportedMediaTypes[matchInfo.SourceTypeIndex].Format;
                }
            }

            // We're calling the ToArray here since not all platforms support the string.Join which takes IEnumerable.
            string supportedTypesAsString = String.Join(", ", supportedPayloadKinds.SelectMany(pk => mediaTypeResolver.GetMediaTypeFormats(pk).Select(mt => mt.MediaType.ToText())).ToArray());
            throw new ODataContentTypeException(Strings.MediaTypeUtils_CannotDetermineFormatFromContentType(supportedTypesAsString, contentTypeName));
        }

        ///
        /// Parses the specified content type header into a media type instance.
        ///
        /// <param name="contentTypeHeader">The content type header to parse.</param>
        /// <param name="charset">The optional charset specified with the content type.</param>
        /// <returns>The <see cref="ODataMediaType"/> of the parsed <paramref name="contentTypeHeader"/>.</returns>
        private static ODataMediaType ParseContentType(string contentTypeHeader, out string charset)
        {
            Debug.Assert(!String.IsNullOrEmpty(contentTypeHeader), "!string.IsNullOrEmpty(contentTypeHeader)");

            // parse the content type header into its parts, make sure we only allow one content type to be specified.
            IList<KeyValuePair<ODataMediaType, string>> specifiedTypes = HttpUtils.MediaTypesFromString(contentTypeHeader);
            if (specifiedTypes.Count != 1)
            {
                throw new ODataContentTypeException(Strings.MediaTypeUtils_NoOrMoreThanOneContentTypeSpecified(contentTypeHeader));
            }

            ODataMediaType contentType = specifiedTypes[0].Key;
            CheckMediaTypeForWildCards(contentType);
            charset = specifiedTypes[0].Value;
            return contentType;
        }

        ///
        /// Gets the default media type for a given payload kind in a given format.
        ///
        /// <param name="supportedMediaTypes">A list of supported media types and formats.</param>
        /// <param name="specifiedFormat">The user-specified format in which to write the payload (can be null).</param>
        /// <param name="actualFormat">The default format for the specified payload kind</param>
        /// <returns>The default media type for the given payload kind and format.</returns>
        private static ODataMediaType GetDefaultMediaType(
            IList<ODataMediaTypeFormat> supportedMediaTypes,
            ODataFormat specifiedFormat,
            out ODataFormat actualFormat)
        {
            for (int i = 0; i < supportedMediaTypes.Count; ++i)
            {
                // NOTE: the supportedMediaTypes are sorted (desc) by format and media type; so the
                //       default format and media type is the first entry in the list
                ODataMediaTypeFormat supportedMediaType = supportedMediaTypes[i];
                if (specifiedFormat == null || supportedMediaType.Format == specifiedFormat)
                {
                    actualFormat = supportedMediaType.Format;
                    return supportedMediaType.MediaType;
                }
            }

            throw new ODataException(Strings.ODataUtils_DidNotFindDefaultMediaType(specifiedFormat));
        }

        ///
        /// Parses the accepted charsets and matches them against the supported encodings for the given <paramref name="payloadKind"/>.
        ///
        /// <param name="acceptCharsetHeader">The Accept-Charset header of the request.</param>
        /// <param name="payloadKind">The <see cref="ODataPayloadKind"/> for which to compute the encoding.</param>
        /// <param name="mediaType">The media type used to compute the default encoding for the payload.</param>
        /// <param name="useDefaultEncoding">true if the default encoding should be returned if no acceptable charset is found; otherwise false.</param>
        /// <returns>The encoding to be used for the response.</returns>
        private static Encoding GetEncoding(string acceptCharsetHeader, ODataPayloadKind payloadKind, ODataMediaType mediaType, bool useDefaultEncoding)
        {
            if (payloadKind == ODataPayloadKind.BinaryValue)
            {
                return null;
            }

            return HttpUtils.EncodingFromAcceptableCharsets(
                acceptCharsetHeader,
                mediaType,
                /*utf8Encoding*/ encodingUtf8NoPreamble,
                /*useDefaultEncoding*/ useDefaultEncoding ? encodingUtf8NoPreamble : null);
        }

        ///
        /// Matches the supported media types against the list of media types specified in the Accept header or ContentType header of the message. Matching follows the
        /// rules for media type matching as described in RFC 2616.
        ///
        /// <param name="sourceTypes">The set of media types to be matched against the <paramref name="targetTypes"/>.</param>
        /// <param name="targetTypes">The set of media types the <paramref name="sourceTypes"/> will be matched against.</param>
        /// <returns>The best <see cref="MediaTypeMatchInfo"/> found during the matching process or null if no match was found.</returns>
        private static MediaTypeMatchInfo MatchMediaTypes(IEnumerable<ODataMediaType> sourceTypes, ODataMediaType[] targetTypes)
        {
            Debug.Assert(sourceTypes != null, "sourceTypes != null");
            Debug.Assert(targetTypes != null, "targetTypes != null");

            MediaTypeMatchInfo selectedMatchInfo = null;

            int sourceIndex = 0;
            if (sourceTypes != null)
            {
                foreach (ODataMediaType sourceType in sourceTypes)
                {
                    int targetIndex = 0;
                    foreach (ODataMediaType targetType in targetTypes)
                    {
                        // match the type name parts and parameters of the media type
                        MediaTypeMatchInfo currentMatchInfo = new MediaTypeMatchInfo(sourceType, targetType, sourceIndex, targetIndex);
                        if (!currentMatchInfo.IsMatch)
                        {
                            targetIndex++;
                            continue;
                        }

                        if (selectedMatchInfo == null)
                        {
                            selectedMatchInfo = currentMatchInfo;
                        }
                        else
                        {
                            int comparisonResult = selectedMatchInfo.CompareTo(currentMatchInfo);
                            if (comparisonResult < 0)
                            {
                                // If the selected match is less specific than the current match, use the current match.
                                selectedMatchInfo = currentMatchInfo;
                            }
                        }

                        targetIndex++;
                    }

                    sourceIndex++;
                }
            }

            if (selectedMatchInfo == null)
            {
                return null;
            }

            return selectedMatchInfo;
        }

        ///
        /// Converts all occurrences of the 'application/json' media type to 'application/json;odata.metadata=minimal'.
        /// This is necessary because for an accept header 'application/json
        /// we want the result to be 'application/json;odata.metadata=minimal'
        ///
        /// <param name="specifiedTypes">The parsed acceptable media types.</param>
        private static void ConvertApplicationJsonInAcceptableMediaTypes(IList<KeyValuePair<ODataMediaType, string>> specifiedTypes)
        {
            if (specifiedTypes == null)
            {
                return;
            }

            for (int i = 0; i < specifiedTypes.Count; ++i)
            {
                ODataMediaType mediaType = specifiedTypes[i].Key;
                if (HttpUtils.CompareMediaTypeNames(mediaType.SubType, MimeConstants.MimeJsonSubType) &&
                    HttpUtils.CompareMediaTypeNames(mediaType.Type, MimeConstants.MimeApplicationType))
                {
                    if (mediaType.Parameters == null ||
                        !mediaType.Parameters.Any(p => HttpUtils.CompareMediaTypeParameterNames(p.Key, MimeConstants.MimeMetadataParameterName)))
                    {
                        // application/json detected; convert it to Json Light
                        IList<KeyValuePair<string, string>> existingParams = mediaType.Parameters != null ? mediaType.Parameters.ToList() : null;
                        int newCount = existingParams == null ? 1 : existingParams.Count + 1;
                        List<KeyValuePair<string, string>> newParams = new List<KeyValuePair<string, string>>(newCount);
                        newParams.Add(new KeyValuePair<string, string>(MimeConstants.MimeMetadataParameterName, MimeConstants.MimeMetadataParameterValueMinimal));
                        if (existingParams != null)
                        {
                            newParams.AddRange(existingParams);
                        }

                        specifiedTypes[i] = new KeyValuePair<ODataMediaType, string>(new ODataMediaType(mediaType.Type, mediaType.SubType, newParams), specifiedTypes[i].Value);
                    }
                }
            }
        }

        ///
        /// Class representing the result of matching two <see cref="ODataMediaType"/> instances.
        ///
        private sealed class MediaTypeMatchInfo : IComparable<MediaTypeMatchInfo>
        {
            /// The default quality value (in the normalized range from 0 .. 1000).
            private const int DefaultQualityValue = 1000;

            /// Index of the source type in the list of all source types.
            private readonly int sourceIndex;

            /// Index of the target type in the list of all target types.
            private readonly int targetIndex;

            ///
            /// Constructor.
            ///
            /// <param name="sourceType">The source <see cref="ODataMediaType"/> to match against the target type.</param>
            /// <param name="targetType">The target <see cref="ODataMediaType"/> to match against the source type.</param>
            /// <param name="sourceIndex">Index of the source type in the list of all source types.</param>
            /// <param name="targetIndex">Index of the target type in the list of all target types.</param>
            public MediaTypeMatchInfo(ODataMediaType sourceType, ODataMediaType targetType, int sourceIndex, int targetIndex)
            {
                Debug.Assert(sourceType != null, "sourceType != null");
                Debug.Assert(targetType != null, "targetType != null");

                this.sourceIndex = sourceIndex;
                this.targetIndex = targetIndex;

                this.MatchTypes(sourceType, targetType);
            }

            ///
            /// Index of the source type in the list of all source types.
            ///
            public int SourceTypeIndex
            {
                get
                {
                    return this.sourceIndex;
                }
            }

            ///
            /// Index of the target type in the list of all target types.
            ///
            public int TargetTypeIndex
            {
                get
                {
                    return this.targetIndex;
                }
            }

            ///
            /// Represents the number of non-* matching type name parts or -1 if not matching at all.
            ///
            public int MatchingTypeNamePartCount
            {
                get;
                private set;
            }

            ///
            /// Represents the number of matching parameters or -1 if neither the source type nor the target type have parameters.
            ///
            public int MatchingParameterCount
            {
                get;
                private set;
            }

            /// The quality value of the target type (or -1 if none is specified).
            public int QualityValue
            {
                get;
                private set;
            }

            ///
            /// The number of parameters of the source type that are used for comparison. All accept-parameters are ignored.
            ///
            public int SourceTypeParameterCountForMatching
            {
                get;
                private set;
            }

            ///
            /// true if this <see cref="MediaTypeMatchInfo"/> represents a valid match (i.e., the source and target types match/are compatible); otherwise false.
            ///
            /// <remarks>
            /// Two types are considered compatible if at least one type name part matches (or we are dealing with a wildcard)
            /// and all the parameters in the source type have been matched.
            /// </remarks>
            public bool IsMatch
            {
                get
                {
                    if (this.QualityValue == 0)
                    {
                        return false;
                    }

                    if (this.MatchingTypeNamePartCount < 0)
                    {
                        // if none of the type name parts match, the types are not compatible; continue with next acceptable type.
                        return false;
                    }

                    if (this.MatchingTypeNamePartCount > 1)
                    {
                        // make sure we matched all the parameters in the source type
                        if (this.MatchingParameterCount != -1 && this.MatchingParameterCount < this.SourceTypeParameterCountForMatching)
                        {
                            return false;
                        }
                    }

                    return true;
                }
            }

            ///
            /// Implementation of <see cref="IComparable<MediaTypeMatchInfo>"/>.
            ///
            /// <param name="other">The <see cref="MediaTypeMatchInfo"/> to compare against.</param>
            /// <returns>
            /// -1 if this instance is a worse match than <paramref name="other"/>.
            /// 0 if both matches are the same.
            /// 1 if <paramref name="other"/> is a better match than this instance.
            /// </returns>
            public int CompareTo(MediaTypeMatchInfo other)
            {
                ExceptionUtils.CheckArgumentNotNull(other, "other");

                if (this.MatchingTypeNamePartCount > other.MatchingTypeNamePartCount)
                {
                    // the current match info matches more type name parts: choose it.
                    return 1;
                }

                if (this.MatchingTypeNamePartCount == other.MatchingTypeNamePartCount)
                {
                    // Now check the parameters and see whether we find a more specific match.
                    if (this.MatchingParameterCount > other.MatchingParameterCount)
                    {
                        return 1;
                    }

                    if (this.MatchingParameterCount == other.MatchingParameterCount)
                    {
                        // check the quality value
                        int qualityComparison = this.QualityValue.CompareTo(other.QualityValue);
                        if (qualityComparison == 0)
                        {
                            // if they also have the same quality value, we choose the one
                            // that appears earlier in the conneg tables; that's the one with the smaller target type index.
                            return other.TargetTypeIndex < this.TargetTypeIndex ? -1 : 1;
                        }

                        return qualityComparison;
                    }
                }

                return -1;
            }

            /// Selects a quality value for the specified type.
            /// <param name="qualityValueText">The text representation of the quality value.</param>
            /// <returns>The quality value, in range from 0 through 1000.</returns>
            /// <remarks>See http://tools.ietf.org/html/rfc2616#section-14.1 for further details.</remarks>
            private static int ParseQualityValue(string qualityValueText)
            {
                int qualityValue = DefaultQualityValue;
                if (qualityValueText.Length > 0)
                {
                    int textIndex = 0;
                    HttpUtils.ReadQualityValue(qualityValueText, ref textIndex, out qualityValue);
                }

                return qualityValue;
            }

            ///
            /// Tries to find a parameter with the specified <paramref name="parameterName"/> in the given list <paramref name="parameters"/> of parameters.
            /// Does not include accept extensions (i.e., parameters after the q quality value parameter)
            ///
            /// <param name="parameters">The list of parameters to search.</param>
            /// <param name="parameterName">The name of the parameter to find.</param>
            /// <param name="parameterValue">The parameter value of the parameter with the specified <paramref name="parameterName"/>.</param>
            /// <returns>True if a parameter with the specified <paramref name="parameterName"/> was found; otherwise false.</returns>
            private static bool TryFindMediaTypeParameter(IList<KeyValuePair<string, string>> parameters, string parameterName, out string parameterValue)
            {
                Debug.Assert(!String.IsNullOrEmpty(parameterName), "!string.IsNullOrEmpty(parameterName)");

                parameterValue = null;

                if (parameters != null)
                {
                    for (int i = 0; i < parameters.Count; ++i)
                    {
                        string candidateParameterName = parameters[i].Key;

                        if (HttpUtils.CompareMediaTypeParameterNames(parameterName, candidateParameterName))
                        {
                            parameterValue = parameters[i].Value;
                            return true;
                        }
                    }
                }

                return false;
            }

            ///
            /// Returns a flag indicating whether a given media type parameter name is the Http quality value parameter.
            ///
            /// <param name="parameterName">The parameter name to check.</param>
            /// <returns>True if the parameter name is for the quality value; otherwise false.</returns>
            private static bool IsQualityValueParameter(string parameterName)
            {
                return HttpUtils.CompareMediaTypeParameterNames(ODataConstants.HttpQValueParameter, parameterName);
            }

            ///
            /// Matches the source type against the media type.
            ///
            /// <param name="sourceType">The source <see cref="ODataMediaType"/> to match against the target type.</param>
            /// <param name="targetType">The target <see cref="ODataMediaType"/> to match against the source type.</param>
            private void MatchTypes(ODataMediaType sourceType, ODataMediaType targetType)
            {
                this.MatchingTypeNamePartCount = -1;

                if (sourceType.Type == "*")
                {
                    this.MatchingTypeNamePartCount = 0;
                }
                else
                {
                    if (HttpUtils.CompareMediaTypeNames(sourceType.Type, targetType.Type))
                    {
                        if (sourceType.SubType == "*")
                        {
                            // only type matches
                            this.MatchingTypeNamePartCount = 1;
                        }
                        else if (HttpUtils.CompareMediaTypeNames(sourceType.SubType, targetType.SubType))
                        {
                            // both type and subtype match
                            this.MatchingTypeNamePartCount = 2;
                        }
                    }
                }

                this.QualityValue = DefaultQualityValue;
                this.SourceTypeParameterCountForMatching = 0;
                this.MatchingParameterCount = 0;

                IList<KeyValuePair<string, string>> sourceParameters = sourceType.Parameters != null ? sourceType.Parameters.ToList() : null;
                IList<KeyValuePair<string, string>> targetParameters = targetType.Parameters != null ? targetType.Parameters.ToList() : null;
                bool targetHasParams = targetParameters != null && targetParameters.Count > 0;
                bool sourceHasParams = sourceParameters != null && sourceParameters.Count > 0;

                if (sourceHasParams)
                {
                    for (int i = 0; i < sourceParameters.Count; ++i)
                    {
                        string parameterName = sourceParameters[i].Key;
                        if (IsQualityValueParameter(parameterName))
                        {
                            // once we hit the q-value in the parameters we know that only accept-params will follow
                            // that don't contribute to the matching. Parse the quality value but don't continue processing
                            // parameters.
                            this.QualityValue = ParseQualityValue(sourceParameters[i].Value.Trim());
                            break;
                        }

                        this.SourceTypeParameterCountForMatching = i + 1;

                        if (targetHasParams)
                        {
                            // find the current parameter name in the set of parameters of the candidate and compare the value;
                            // if they match increase the result count
                            // NOTE: according to RFC 2045, Section 2, parameter values are case sensitive per default (while
                            //       type values, subtype values and parameter names are case-insensitive); however, we
                            //       are more relaxed in ODL and allow case insensitive values.
                            string parameterValue;
                            if (TryFindMediaTypeParameter(targetParameters, parameterName, out parameterValue) &&
                                String.Compare(sourceParameters[i].Value.Trim(), parameterValue.Trim(), StringComparison.OrdinalIgnoreCase) == 0)
                            {
                                this.MatchingParameterCount++;
                            }
                        }
                    }
                }

                // if the source does not have parameters or it only has accept extensions
                // (parameters after the q value) or we match all the paramters we
                // have a perfect parameter match.
                if (!sourceHasParams ||
                    this.SourceTypeParameterCountForMatching == 0 ||
                    this.MatchingParameterCount == this.SourceTypeParameterCountForMatching)
                {
                    this.MatchingParameterCount = -1;
                }
            }
        }

        ///
        /// Class representing key of match info cache.
        ///
        private sealed class MatchInfoCacheKey
        {
            ///
            /// Constructor.
            ///
            /// <param name="resolver">The media type resolver to use.</param>
            /// <param name="payloadKind">Kind of the payload.</param>
            /// <param name="contentTypeName">Name of content type.</param>
            public MatchInfoCacheKey(ODataMediaTypeResolver resolver, ODataPayloadKind payloadKind, string contentTypeName)
            {
                this.MediaTypeResolver = resolver;
                this.PayloadKind = payloadKind;
                this.ContentTypeName = contentTypeName;
            }

            ///
            /// Type of the mediaTypeResolver.
            ///
            private ODataMediaTypeResolver MediaTypeResolver { get; set; }

            ///
            /// Kind of the payload.
            ///
            private ODataPayloadKind PayloadKind { get; set; }

            ///
            /// Name of content type.
            ///
            private string ContentTypeName { get; set; }

            ///
            /// Returns a value indicating whether this instance is equal to a specified object.
            ///
            /// <param name="obj">An object to compare with this instance.</param>
            /// <returns>true if obj is equal to this instance; otherwise, false.</returns>
            public override bool Equals(object obj)
            {
                MatchInfoCacheKey cacheKey = obj as MatchInfoCacheKey;
                return cacheKey != null &&
                    this.MediaTypeResolver == cacheKey.MediaTypeResolver &&
                    this.PayloadKind == cacheKey.PayloadKind &&
                    this.ContentTypeName == cacheKey.ContentTypeName;
            }

            ///
            /// Returns the hash code for the value of this instance.
            ///
            /// <returns>A 32-bit signed integer hash code.</returns>
            public override int GetHashCode()
            {
                int result = this.MediaTypeResolver.GetHashCode() ^ this.PayloadKind.GetHashCode();
                return this.ContentTypeName != null ? result ^ this.ContentTypeName.GetHashCode() : result;
            }
        }

        ///
        /// Class representing the concurrent cache for match info.
        ///
        private sealed class MatchInfoConcurrentCache
        {
            ///
            /// Max size of the elements that the cache can contain.
            ///
            private readonly int maxSize;

            ///
            /// The dictionary to save elements.
            ///
            private IDictionary<MatchInfoCacheKey, MediaTypeMatchInfo> dict;

            ///
            /// Constructor.
            ///
            /// <param name="maxSize">Max size of the elements that the cache can contain.</param>
            public MatchInfoConcurrentCache(int maxSize)
            {
                this.maxSize = maxSize;
                this.dict = new Dictionary<MatchInfoCacheKey, MediaTypeMatchInfo>(maxSize + 1);
            }

            ///
            /// Gets the value associated with the specified key.
            ///
            /// <param name="key">The key whose value to get.</param>
            /// <param name="value">The value associated with the specified key, if the key is found; otherwise, null.</param>
            /// <returns>true if the cache contains an element with the specified key; otherwise, false.</returns>
            public bool TryGetValue(MatchInfoCacheKey key, out MediaTypeMatchInfo value)
            {
                lock (this.dict)
                {
                    return dict.TryGetValue(key, out value);
                }
            }

            ///
            /// Adds an element with the provided key and value to the cache.
            ///
            /// <param name="key">The key of the element to add.</param>
            /// <param name="value">The value of the element to add.</param>
            public void Add(MatchInfoCacheKey key, MediaTypeMatchInfo value)
            {
                lock (this.dict)
                {
                    if (!dict.ContainsKey(key))
                    {
                        if (dict.Count == maxSize)
                        {
                            dict.Clear();
                        }

                        dict.Add(key, value);
                    }
                }
            }
        }
    }
}


Have your possessions been damaged by a fire or flood in Astor, Florida. Contents cleaning by ServiceMaster Restore by DNP offers amazing results. Just as we can restore your property to it's pre-disaster condition, we are fully equipped to handle the cleaning of your hard and soft contents. You would be amazed at how many damaged items can be restored to like new conditions that were affected by a flood or fire. ServiceMaster Restore by DNP has been restoring damaged goods with contents cleaning in Astor since 2011. Call the experts today at ServiceMaster Restore by DNP.
The content cleaning experts at ServiceMaster Restore by DNP utilize the latest cleaning system technology to restore your damaged possessions. If you have experienced water damage or a fire and need contents cleaned in Astor, You've found the right restoration company. All items are take to our state of the art contents cleaning facility. Items are stored in our climate controlled facility and monitored throughout the process. We hope that you'll never need our contents restoration services, but if you ever do, we are standing by to help.


The Bank of Ireland Economic Pulse came in at 90.5 in November 2017. The index, which combines the results of the Consumer and Business Pulses, was unchanged on the month. Households were less upbeat about economic prospects this month, while the business picture was little changed.
The latest reading is 4.6 higher than a year ago when the outcome of the US Presidential election, coming soon after the Brexit vote and amid some industrial tension at home, unsettled households and firms. However with little actual policy implementation to date, the hit to economic sentiment from Trump's agenda looks to be waning.
Discussing the Economic Pulse, Dr. Loretta O'Sullivan, Group Chief Economist, Bank of Ireland said: "This time last year the outcome of the US Presidential election caught many by surprise. It followed closely on the heels of the UK's decision to leave the EU and also came in the midst of some industrial tension at home. All of this served to unsettle households and firms, with the Economic Pulse reading in November 2016 the lowest in the series' history. But with the Trump administration making little headway in implementing its agenda over the past year, the hit to sentiment seems to be waning, whereas Brexit-related uncertainty is continuing to take a toll.
The protectionist nature of Trump's policy agenda is a concern for Ireland because of the open, export-orientation of our economy and the importance of foreign direct investment by US multinationals. Reflecting this, Economic Pulse research conducted earlier in the year with Irish firms for whom prospective US policy changes are a live issue found that roughly one in four in the industry and services sectors had pressed the pause button on their investment plans for this year.
At 95.9 in November 2017, the Consumer Pulse was down 1.4 on last month's reading but up 7.6 on this time last year. Households were less upbeat about the economic outlook this month, though their assessment of their own financial situation was little changed. With the festive season approaching, one in five indicated that they plan on spending more on Christmas presents this year compared with last year, while 57% intend to spend about the same. Similarly, 28% of retailers expect their Christmas turnover to be up on last year, with around half expecting it to be much the same.
The Business Pulse was broadly unchanged in November 2017, coming in at 89.1. Sentiment among construction firms rose sharply this month, with the Industry and Services Pulses also ticking up. While the Retail Pulse lost some ground, this comes on the back of a strong performance last month and broadly positive expectations for the Christmas trading period. The November data also show that two in five businesses expect to spend more on investment in 2018 compared with this year. A range of factors were mentioned as having an impact on firms' plans, with demand from customers, financial and technical conditions generally seen as supportive. The 'wait and see' approach to investment decisions that many Irish firms adopted this year in response to Brexit-related uncertainty seems set to continue into 2018 though, with around half of those affected by the UK's decision to leave the EU putting their plans on hold.
The Bank of Ireland Regional Pulses combines the views of consumers and businesses in the different parts of the country. The 3 month moving averages show that sentiment was up in Dublin in November 2017, broadly unchanged in Munster and down in the Rest of Leinster. Softer sentiment was particularly apparent in Connacht/Ulster, where households were less upbeat about the economy this month.
Meanwhile firms' expectations for near-term business prospects and hiring intentions were little changed in all regions. With the festive season getting underway, retailers in Connacht/Ulster were a little more downbeat than elsewhere, with 20% expecting their Christmas turnover to be down on last year, double the figure for Dublin.


As cloud adoption continues to transform business, today's global enterprises are challenged with managing a growing amount of information living outside of the data center. The rapid adoption of IoT and increasingly mobile workforce are exacerbating the problem. Ensuring secure data sharing and efficient backup poses capacity and bandwidth considerations as well as policy and regulatory compliance issues.
In his session at 19th Cloud Expo, Kurt Kuckein, Director of Product Management at DDN, explored how to address the massive scalability requirements of Big Data and the need to provide secure cloud collaboration, file sharing and content distribution across the entire enterprise.
Kurt Kuckein is Director of Product Management at DDN and his responsibilities include product strategy for DDN's award winning portfolio of hardware and software products. He joined DDN in May of 2015. He has 15 years of storage technology product management experience with stints in hardware, software and end-to-end solution development. Prior to joining DDN, he worked at EMC in the Data Protection Division, Silicon Graphics in the Storage Solutions Group, and CGNET's hosted technology management services. Kurt holds an MBA from Santa Clara University with an emphasis in product and brand management and a bachelor's degree in political science from the University of San Diego.
20th International Cloud Expo, taking place June 6-8, 2017, at the Javits Center in New York City, NY, will feature technical sessions from a rock star conference faculty and the leading industry players in the world.
Cloud Expo is the single show where delegates and technology vendors can meet to experience and discuss the entire world of the cloud.
Learn what is going on, contribute to the discussions, and ensure that your enterprise is as "Cloud-Ready" as it can be!


The Ramada Busan Hotel is re-opening as the Sunset Business Hotel.After the big renovation, however, the new management team decided to change the hotel name to the Sunset Business Hotel. They have every confidence that the hotel will provide the best quality service through their own management skills. They continually strive to establish a close relationship with the clients to insure complete customer satisfaction. The grand opening of the Sunset Business Hotel was launched on the 28th of October, 2008.The worldwide reservation and marketing system has been established by the hotel's management to specialize in customer satisfaction and convenience.The hotel's 72 rooms have been designed with individual concepts, which are luxurious, modern, and classically comfortable to provide customized service. Escape to Sunset Hotel for elegant rooms, first class service, karaoke entertainment, relaxing Thai massage, and a quality restaurant. The Hotel is proud of the views of Haeundae Beach from the hotel, which the customer can conveniently enjoy while taking a relaxing rest in a whirlpool bath. They will endlessly try to make this the best hotel experience by considering the customers first, with service provided from the point the view of customers. They promise is to provide the best service and to make the Sunset Business Hotel the best facility for the customer. The Hotel also provides Banquet facilities, Bar, Business centre, Concierge, Conference facilities, Currency exchange, Disabled facilities, Doctor on call, Dry cleaning, Internet access - High speed, Laundry service, Lift/Elevator, Lobby, Parking facilities - at cost, Reception, Restaurant, Room service, Safe deposit box and Spa services.
Haeundae hotel with restaurants:This Haeundae hotel is located near Haeundae Beach and Busan Aquarium. Another nearby point of interest is BEXCO. :Sunset Business Hotel features restaurants and a bar/lounge.


text:
UK pavilion shortlist announced for milan expo 2015
architecture 0 shares connections: 71
all images courtesy of UK trade & investment / malcolm reading consultants
shortlisted proposals have been revealed by UK trade & investment of the eight teams competing to build the UK pavilion at milan expo 2015. listed anonymously, the finalist team leads in alphabetical order are: AL_A, allford hall monaghan morris and studio myerscough, asif khan, barber & osgerby, david kohn architects, grant associates, paul cocksedge studio, and wolfgang buttress studio. the structure will showcase britain's contribution to research, innovation and entrepreneurship in response to the global challenges addressed by the expo theme 'feeding the planet, energy for life'. the UK's thesis for the scheme is 'grown in britain: shared globally'.
'I am excited by the quality of these ideas. the creative sector has truly risen to the challenge of designing a world-class UK pavilion that builds on the incredible success of our presence in shanghai. it's clear from the quality of the shortlisted ideas that the UK will have an extraordinary presence at milan expo 2015,' explained hannah corbett, the UK commissioner general and project director.
malcolm reading, architect and competition organizer said: 'this competition has run to an ambitious timescale and the finalists have responded admirably. 'designing a pavilion is a unique challenge: the structure needs to say it all in a glance yet continue to intrigue over the life of the expo. these are high-caliber teams who have produced a diverse and sparkling set of propositions and we're looking forward to their jury presentations.'
the eight finalists will present their concept designs to the competition jury on may 1 with the winner to be announced later in the month. see below for more details on each proposed scheme.
the design references ai wei wei's sunflower seeds, reducing the scale of every person on earth
referencing the terracotta army and ai wei wei's sunflower seeds, the proposed pavilion attempts to house every single person on earth, through reducing their scale by one hundredth of their real size. in this way 7.2 billion people are able to fit onto the expo plot in 300 vertical layers. consequently, the 80 x 15 x 12 meter structure will contain the entire world's population in three dimensions.
the scheme takes the form of a three-dimensional infinity loop
team 2's scheme celebrates the UK's island setting within two connected environments: sea and land. taking the form of a three-dimensional infinity loop, the design represents the importance of joined up food chains. within the dynamic landscapes, the pavilion communicates the relationship the british food industry shares with weather, water and soil cycles in addition to specific future production technologies, processes and produce.
the design reflects the importance of joined up food chains
1,296 reusable telegraph poles create a instant timber forest
through dissolving the border between internal and external space, team 3 has established an organic sense of fluidity. 1,296 reusable telegraph poles create a timber forest providing guests with a calm and inviting space that takes visitors on a journey of exploration. publicly accessible computer tablets installed with augmented reality software, transform the pavilion's physical environment into a digital world of sound and color.
the design is a working, ecological and self-sustaining model that allows visitors to engage in debate
reflecting the expo's theme, team 4's pavilion celebrates how british agriculture and technology have had a positive impact on the world – providing solutions to global problems. the design is a working, ecological and self-sustaining model that allows visitors to engage in debate, creating entertaining experiences through a range of technologies and materials.
guests to the expo enter through an orchard, discovering a wildflower meadow before entering a 'virtual hive'
entitled 'BE', team 5's pavilion explores ways in which research and technology are combating the plight of the honeybee. guests to the expo meander through an orchard, discovering a wildflower meadow before entering a 'virtual hive', which pulsates, buzzes and glows according to signals from a real hive. the proposal explores the life of the bee colony through an immersive sensory experience, leaving visitors with a lasting reminder of the british landscape.
inside a roofless, black container, visitors walk along paths cut through a vast volume of water
the pavilion proposed by team 6 uses water as a metaphor to address the expo's theme of feeding the planet. inside a roofless, black container, visitors walk along paths cut through a vast volume of water representing their water footprint. the design attempts to make visible the statistic that 80% of the water we use is hidden inside our food.
once the expo has closed, the glasshouse will be relocated to the UK for use as a research facility
team 7's 'strawberry fields forever' tells the story of how british scientific and technological innovations are benefiting food production and consumption on a global scale. a lightweight pavilion comprising a state-of-the-art glasshouse invites visitors to journey through the sights and sounds of future fruit cultivation. once the expo has closed, the glasshouse will be relocated to the UK for use as a research facility.
the design celebrates the people and ideas that are leading scientific research, agriculture and food production
the design proposed by team 8 provides each guest with information about how they can help to meet the global food challenges. the immersive, memorable and friendly journey based around the four themes of THINKERS + GROWERS + MAKERS = SHARERS celebrates the people and ideas that are leading scientific research, agriculture, food production and food consumption.
why dont they tell us who designed them?
Very interesting ideas here with all the teams…team 6 have nice visuals…but is it just me or this is a blatant copy of Richard Wilson oil installation 20:50 and Martin creed's neon statement? I love architecture but British artists are always more original…
EXPO MILAN 2015 (71)
carlo ratti to transform milan's world expo site into an innovation hub
terrain installs 560m2 of forest in breathe austria pavilion at expo milano 2015
besame mucho restaurant honors the acapulco chair in expo milan 2015
lino russo abstracts milan expo architecture for skymetric series
inside expo's japan pavilion with teamlab founder toshiyuki inoko

redpajama_set_name: RedPajamaCommonCrawl


From this page you have the option of viewing and ordering all product that we have in our inventory for Designs by Reminisce. You may also return to another category by clicking on the link in the left column of this page.
12x12 inch sheet of single-sided scrapbook paper. Acid free.
12x12 inch sheet of double-sided scrapbook paper. Acid free.
4 1/2 x 9 1/2 inch sheet of die cut glittered stickers. Reminisce item number F-100. Acid free.
12x12 sheet of single sided scrapbook paper. Reminisce item number IVB-000. Acid free.
12x12 sheet of single sided scrapbook paper. Reminisce item number IVB-010. Acid free.
4 1/2 x 9 1/2 sheet of die cut stickers. Reminisce item number TFC-102. Acid free.
12x12 sheet of die cut scrapbook paper. Reminisce item number TFC-030. Acid free.
4 1/2 x 9 1/2 sheet of die cut stickers. Reminisce item number TFC-118. Acid free.
12x12 sheet of single sided scrapbook paper by Reminisce Designs. Acid free.
12x12 inch sheet of single-sided scrapbook paper from Designs by Reminisce. Acid free.
Approximately 5 1/2 x 11 inch sheet of stickers. Acid free.
12x12 sheet of double sided scrapbook paper by Reminisce Designs. Acid free.
4 1/4 x 12 inch sheet of die cut stickers. Acid free.
12x12 sheet of single sided scrapbook paper. Reminisce item number CC-003. Acid free.
Approximately 4 1/2 x 9 1/2 inch sheet of die cut stickers. Acid free.
4 1/2 x 9 1/2 inch sheet of die cut stickers. Reminisce item number AH-100. Acid free.
4x7 inch sheet of themed rub-ons.
8 1/2 x 13 1/2 sheet of stickers. Acid free.
12x12 sheet of double sided scrapbook paper. Acid and lignin free.
12x12 inch sheet of scrapbook paper. Reminisce item number BTS-003. Acid free.
Approximate 4x12 inch sheet of rub-ons. Reminisce item number FB-008. Acid free.
Approximate 4x12 inch sheet of rub-ons. Reminisce item number FB-009. Acid free.
Approximate 4x12 inch sheet of rub-ons. Reminisce item number FB-014. Acid free.
Approximate 4x12 inch sheet of rub-ons. Reminisce item number FB-021. Acid free.
Approximate 4x12 inch sheet of rub-ons. Reminisce item number FB-028. Acid free.
12x12 sheet of double sided scrapbook paper. Reminisce item number BWA-002. Acid free.
12x12 sheet of double sided scrapbook paper. Reminisce item number BWA-005. Acid free.
12x12 sheet of double sided scrapbook paper. Reminisce item number BWA-006. Acid free.
8x2 inch sheet of rub-ons. Reminisce item number PH-002. Acid free.
8x2 inch sheet of rub-ons. Reminisce item number PH-006. Acid free.
8x2 inch sheet of rub-ons. Reminisce item number PH-015. Acid free.
8x2 inch sheet of rub-ons. Reminisce item number PH-016. Acid free.
8x2 inch sheet of rub-ons. Reminisce item number PH-021. Acid free.
8x2 inch sheet of rub-ons. Reminisce item number PH-022. Acid free.
8x2 inch sheet of rub-ons. Reminisce item number PH-037. Acid free.
8x2 inch sheet of rub-ons. Reminisce item number PH-042. Acid free.
8x2 inch sheet of rub-ons. Reminisce item number PH-063. Acid free.
Approximately 8 1/2 x 12 inch sheet of die cut stickers. Acid free. Limited quantity.
4 x 7 inch sheet of shamrocks and celtic images rub-ons. Reminisce item number GD-102. Acid free.
12x12 inch sheet of die cut glittered stickers. Reminisce item number GD-107. Acid free.
Approximate 4x12 inch sheet of rub-ons. Reminisce item number HE-102. Acid free.
Approximately 2 1/2 x 10 inch sheet of stickers. Reminisce item number HE-119. Acid free.
Approximately 2 1/2 x 10 inch sheet of stickers. Reminisce item number HE-120. Acid free.
12x12 sheet of double sided scrapbook paper. Reminisce item number MS-001. Acid free.
12x12 sheet of double sided scrapbook paper. Reminisce item number MS-002. Acid free.
12x12 sheet of double sided scrapbook paper. Reminisce item number MS-005. Acid free.
12x12 inch sheet of die cut stickers. Acid free. Limited quantity.
12x12 inch sheet of glittered scrapbook paper. Reminisce item number F-000. Acid free.
12x12 inch sheet of glittered scrapbook paper. Reminisce item number F-001. Acid free.
12x12 inch sheet of shimmer double-sided scrapbook paper. Reminisce item number F-005. Acid free.
4 1/2 x 9 1/2 inch sheet of die cut glittered stickers. Reminisce item number F-101. Acid free.
4 x 7 inch sheet of heart shaped rub-ons. Reminisce item number F-105. Acid free.
4 x 7 inch sheet of heart shaped rub-ons. Reminisce item number F-106. Acid free.
4 x 7 inch sheet of heart shaped rub-ons. Reminisce item number F-107. Acid free.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-000.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-003.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-006.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-007.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-011.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-016.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-019.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-023.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-025.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-026.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-028.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-029.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-030.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-032.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-033.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-035.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-036.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-037.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-038.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-042.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-043.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-044.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-045.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-046.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-047.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-049.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JS-054.
12x12 inch sheet of double-sided scrapbook paper. Acid free. Limited quantity.
12x12 sheet of double sided scrapbook paper. Reminisce item number EST-005. Acid free.
12x12 sheet of single sided shimmer scrapbook paper. Reminisce item number EA-005. Acid free.
12x12 sheet of single sided shimmer scrapbook paper. Reminisce item number EA-007. Acid free.
12x12 sheet of single sided shimmer scrapbook paper. Reminisce item number EA-009. Acid free.
12x12 sheet of double sided shimmer scrapbook paper. Reminisce item number BM-003. Acid free.
12x12 sheet of die-cut, scalloped and glittered scrapbook paper. Reminisce item number BM-006. Acid free.
12x12 sheet of die-cut, scalloped and glittered scrapbook paper. Reminisce item number BM-007. Acid free.
12X12 sheet of laser cut die-cuts. Acid free.
12x12 inch sheet of glittered single-sided scrapbook paper from Designs by Reminisce. Acid free.
Approximate 4x12 inch sheet of stickers. Reminisce item number CT-106. Acid free.
12x12 sheet of double sided scrapbook paper. Reminisce item number AF-000. Acid free.
Approximately 2 1/2 x 10 inch sheet of stickers. Reminisce item number AF-107. Acid free.
Approximately 2 1/2 x 10 inch sheet of stickers. Reminisce item number AF-108. Acid free.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your athletes sports pages. Acid and lignin free. Designs by Reminisce item number RS-124.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your scrapbook pages. Acid and lignin free. Designs by Reminisce item number RSD-181.
12x12 sheet of die cut stickers. Reminisce item number SAS-101. Acid free.
4 1/2 x 9 1/2 inch sheet of die cut stickers. Reminisce item number CIL-100. Acid free.
Approximate 4x12 inch sheet of stickers. Reminisce item number IB-100. Acid free.
12x12 sheet of die cut stickers. Reminisce item number IB-101. Acid free.
4 1/4 x 12 inch sheet of die cut stickers. Acid free. Limited quantity.
12x12 sheet of double sided scrapbook paper. Reminisce item number LB-000. Acid free.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your memories. Acid and lignin free. Designs by Reminisce item number RSD-203.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your scrapbook pages. Acid and lignin free. Designs by Reminisce item number RSD-204.
12x12 inch sheet of double-sided scrapbook paper. Reminisce item number ACS-003. Acid free.
4 1/4 x 12 inch sheet of die cut stickers. Reminisce item number ACS-101. Acid free.
12x12 sheet of double sided scrapbook paper. Reminisce item number DP-002. Acid free.
12x12 inch sheet of double-sided scrapbook paper. Reminisce item number DS-000. Acid free.
12x12 sheet of double sided scrapbook paper. Reminisce item number HAR-002. Acid free.
4 1/4 x 12 inch sheet of die cut stickers. Reminisce item number HAR-101. Acid free.
4 1/4 x 12 inch sheet of die cut stickers. Reminisce item number HAR-103. Acid free.
12x12 sheet of double sided scrapbook paper. Reminisce item number HAR-020. Acid free.
12x12 inch sheet of double-sided scrapbook paper. Reminisce item number AFL-001. Acid free.
12x12 inch sheet of double-sided scrapbook paper. Reminisce item number AFL-003. Acid free.
4 1/4 x 12 inch sheet of die cut stickers. Reminisce item number AFL-100. Acid free.
12x12 inch sheet of die cut stickers. Reminisce item number AFL-101. Acid free.
12x12 sheet of double sided scrapbook paper. Reminisce item number SHN-000. Acid free.
4 1/4 x 12 inch sheet of cardstock stickers. Reminisce item number SHN-100. Acid free.
12x12 sheet of double sided scrapbook paper. Reminisce item number EXD-000. Acid free.
12x12 sheet of double sided scrapbook paper. Reminisce item number EXD-003. Acid free.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JST-018.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JST-034.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free. Designs by Reminisce item number JST-040.
Dimensional stickers from Designs by Reminisce offer an unparalleled way to highlight your adventures around the world. Acid and lignin free.
12x12 sheet of double sided scrapbook paper. Reminisce item number EXD-001. Acid free.
12x12 inch sheet of double-sided scrapbook paper from Designs by Reminisce. Acid free.
12x12 inch sheet of double-sided scrapbook paper. Reminisce item number IMP-001. Acid free.
12x12 inch sheet of double-sided scrapbook paper. Reminisce item number IMP-002. Acid free.
12x12 inch sheet of double-sided scrapbook paper. Reminisce item number ELE-000. Acid free.
12x12 inch sheet of double-sided scrapbook paper. Reminisce item number ELE-001. Acid free.
12x12 inch sheet of double-sided scrapbook paper. Reminisce item number ELE-002. Acid free.
12x12 inch sheet of double-sided scrapbook paper. Reminisce item number ELE-004. Acid free.


text:
Author Charvak Londhe Published on December 19, 2022 1 min read
Makoto Shinkai's new venture Suzume no Tojimari has already made waves since its pre-release and seems to do so continuously. After its premiere in Japan, the film has already crossed 6.269 billion yen, about US$45.5 million in its first 17 days alone. While selling an aggregate of 4.60 million tickets in total.
Suzume no Tojimari's current exploits at the Japanese box office have resulted in a record-breaking feat. The film has managed even to crunch up Kimi no na wa (Your Name), the previous masterpiece by Makoto Shinkai, by selling 38.7% more tickets and earning 47.4% more than the film.
Sony Pictures Entertainment, Wild Bunch International, and Crunchyroll will release the movie worldwide, except in Asia, in early 2023. Crunchyroll will release the film in North America, while Sony Pictures and Crunchyroll will handle distribution in Latin America, New Zealand, Australia, the Middle East, Africa, South America, and portions of Europe.
A 17-year-old girl from a small town in Kyushu discovers a seemingly normal door in ruins, its unusual appearance, and being mesmerized by its power, she opens the door, which releases destruction and natural calamities. Multiple doors begin to open simultaneously all across Japan. Now it's up to Suzume to close these doors again.
Makoto Shinkai's previous two films Weathering with you and the unforgettable Kimi no na wa (Your name), were critically and commercially well received, and Suzume no Tojimari looks on the same track as its predecessors. Makoto Shinkai's films are not just anime but rather cinematic events.
While we eagerly await his latest tour de force, you could always rewatch the magic of Shinkai's previous films by streaming them again.
anime newssuzume no tojimari
Charvak Londhe
Charvak is an Anime Enthusiast and a Cinephile who also loves Music and is an Avid reader. In his spare time, he is often writing his own stories & creating his own characters. Or he just might be daydreaming about running away to Japan.
Junji Ito Maniac: Japanese Tales of the Macabre Unveils Trailer, Release Date, and More


text:
And What About Papal Primacy? – Robert Hugh Benson's The Religion of the Plain Man
Posted by Rev. Kevin Bezner | Apr 16, 2017 | Books, Catholic Church, Faith, Featured, Literature, Popes, Theology | 0 |
John considers himself Christian, but he doesn't attend services or liturgy. He wants to learn more, so he begins to explore various Christian denominations.
After meeting with representatives of a number of them, he is told that as a Christian all he has to do is read the Bible and worship with any denomination that appeals to him since there is little difference between them.
This answer satisfies John at first, but he reads the Bible and doesn't find the clear guidance he had expected. Another problem he finds is that he cannot understand what he is reading on his own. He decides that he needs a guide and begins searching for one.
John is the name Robert Hugh Benson (1871-1914) has given his common man on a spiritual quest in his splendid book of Catholic apologetics and evangelization, The Religion of the Plain Man.
Originally published in 1906, the book collects six lectures Benson delivered at the Church of Our Lady and the English Martyrs in Cambridge, England. A new edition of the book has been published by Tan Books.
Benson is best known for his 1907 novel The Lord of the World, which examines the coming of the anti-Christ and the end of the world. The book has been praised by, among others, Popes Benedict XVI and Francis, as well as the critic Joseph Pearce.
Benson also is known for his conversion to the Catholic Church, which Pearce says shocked the Anglican establishment of his times; Benson was ordained to the Anglican priesthood in 1895 by his father, Edward White Benson, who was then the Archbishop of Canterbury.
About a year after his ordination, Benson began exploring questions he had about the Anglican faith. Much like John his questions led him to the Catholic Church, and he converted in 1903. In 1904, he was ordained as a Catholic priest.
The Religion of the Plain Man follows John as he attempts to understand the Bible and determine where he will worship. He meets with the various Christian of England – a Baptist minister, a Salvation Army captain, a Presbyterian, a Congregationalist, a Wesleyan, a Unitarian.
Their different answers to his questions leave him with one conclusion: "… namely that the Bible is insufficient as a guide to true religion."
John approaches a friend, a member of the Church of England, and his description of the liturgy, creed, and sacraments leads him to become a member as well. Soon, however, he questions his decision and he begins to examine the claims of the Roman Catholic Church.
John considers the world's perception of the Catholic Church; the Church's unity. He returns to the Bible to examine the Church's claims. He purchases a Penny Catechism to learn what the Church teaches.
John's examination of the Catholic Church must have been similar to Benson's own, since he spends a good amount of time examining papal primacy. The book, in fact, includes an excellent appendix that lists the references to Peter in Scripture and references to the primacy of the papacy in writings of the Church Fathers through the fifth century.
John's examination eventually leads him to conclude:
"Simon is Peter, not because he is a stone by nature, or even by grace, but because in the inscrutable decrees of God he is chosen to be the foundation-stone of an institution which Christ names His Church. There is only one Church in Christendom which claims to be built upon an apostle; and that one whose centre is Rome, where Peter ruled and his body lies. As for the gates of hell, is there any other institution in Christendom which compares with this for immovability, authority and impressiveness? One was built upon the fire of Luther, another upon the piety of Wesley, another upon the lusts of a king and the independent spirit of a nation. These have stood for varying periods, and not one of them for more than four hundred years."
Benson's John examines many more points, large and small, concerning the Catholic Church. Through them all Benson is eloquent in his descriptions of the Church and its teaching, and is respectful of the teachings of the various Christian denominations he discusses.
The Religion of the Plain Man is a concise, thoughtful, gracious, persuasive, and beautifully written account of a convert's journey and the reasons why one might wish to enter into communion with the Catholic Church.
This is a book that will benefit anyone interested in learning about the teachings of the Catholic Church, or the journey of a convert. It also is a book that any Catholic would benefit from reading, particularly apologists and those lukewarm in the faith.
PreviousTrying Another Kind of Love
NextGuilt By Association? The Religion of Peace Strikes Again!
Rev. Kevin Bezner
Rev. Kevin Bezner, a contributing editor to TCR, is a deacon of the Ukrainian Catholic Eparchy of St. Josaphat in Parma, Ohio, and serves at St. Nicholas Ukrainian Catholic Mission in Raleigh, N.C. A poet, Deacon Kevin's recent book is Following the Light: New and Selected Poems, a conversion story in poetry. His articles have appeared in The Catholic Thing and Lay Witness, among others.
Fr. Philippe on the Beatitudes – "The Eight Doors of the Kingdom"
Why Review Kids' Books?
Should a Muslim Be President? Carson, Krauthammer, and the Constitution
Kavanaugh Agonistes: The Nightmare From Foggy Bottom


The new Auto Jr now puts the convenience of automatic filling in a size and price range for every laboratory. Auto Jr features the Auto-Tend II liquid nitrogen controller and alarm providing LN2 level control and audible / visual alarms with remote contacts for security.
The unique fiberglass restricted-opening neck design reduces LN2 consumption rates far below other auto-filling units. In fact, under laboratory testing providing one opening, per day, the Auto Jr operated and maintained "cryogenic temperatures" for over a month on one 165-liter LN2 supply tank. Competitive units can consume three or four per month.
The Auto Jr has also been specifically engineered to provide cryogenic vapor temperatures throughout the tank well below the critical -135°C range. With as little as two inches of liquid, vapor temperatures of -185°C or lower can be maintained on the highest shelf. The convenient hanging rack design enables easy access to all samples without the use of a mechanical "Lazy Susan".
The Auto Jr is the economical auto-fill for every lab. Every Auto Jr comes standard with: 6ft. stainless-steel armor-plated transfer hose, 1/3 year parts and labor warranty, roller base, stainless steel inventory racks, and the Auto-Tend II LN2 controller.
PS Package systems come with CryoGloves, inventory racks, and polycarbonate inventory boxes.
**Static Evaporation Rate and Static Holding Time are nominal. Actual rate may be affected by the nature of the contents, atmospheric conditions, container history and manufacturing tolerances.


text:
{% extends "layout.html" %}
{% from 'build_line.html' import build_table %}
{% import 'forms.html' as forms %}

{% block content %}

Last {{ num_builds }} finished builds: {{ branches|join(', ')|e }}

{% if builders %}

of builders: {{ builders|join(", ")|e }}

{% endif %}

{{ build_table(builds, True) }}

{% if num_building > 0 %}
  {% if authz.advertiseAction('stopBuild') %}

Stop All Builds

    {{ forms.stop_build("builders/_all/stopall", authz, on_all=True, label='All Builds') }}
  {% endif %}
{% endif %}

{% if num_online > 0 %}
  {% if authz.advertiseAction('forceAllBuilds') %}

Force All Builds

    {{ forms.force_build("builders/_all/forceall", authz, True) }}
  {% endif %}
{% endif %}

{% endblock %}

redpajama_set_name: RedPajamaGithub


text:
It is with great satisfaction that real-time education of our American Public about the need for missile defense was made apparent by our nation's major news media outlets from Television, Front Page Newspapers and on the Web this past week, CNN, The Washington Post. It is with deeper satisfaction that within our Congress, the United States Senate responded and reflected our public will on this issue by an unprecedented vote of 98-0 for additional support for Missile Defense. Clearly the deployment and development of missile defense is a bi-partisan priority that is in sync with the views and beliefs of the American Public.
This past week our country saw positive movement towards missile defense, with the continuing success of our "hit to kill" systems, represented by another on-the-mark sea-based interceptor test on June 22 and the reported deployment of the PAC-3 interceptor system and a forward-based X-band radar in Japan. The PAC-3 will help defend Japan and our deployed forces there from a short-range missile attack. According to major news sources and networks, it has been leaked that the President of the United States has ordered the Department of Defense to a twenty-four hour emergency operational missile defense capability to protect the territory of the United States that includes space, sea and land sensors and the use of eleven ground-based interceptors that are in silos in California and Alaska.
These significant movements have caused an apparent delay by North Korea in launching its missile and perhaps withdrawing their attempted long-range missile test. Specifically, the deployment of our missile defense has put forward two major policy positions for our country:
Missile Defense has given the State Department a valuable diplomatic tool in negotiating and deterring North Korea's intentions.
– Missile Defense has taken the pressure off of a potential Presidential and Congressional decision for a preemptive strike on the North Korean missile site that could escalate into a major international crisis, Loss of American and North Korean lives and innocent bloodshed and be taken as act of war with severe ramifications.
The current crisis in North Korea has galvanized the international community and strengthened the US's partnerships to engage and deploy Missile Defense. The United Kingdom began an analysis for deployment of missile defense, and NATO in Brussels has stepped up its involvement with Missile Defense. Most notably, the Japanese people have become acutely aware of the need for protection, as it seeks self-protection as well as integrating with our current missile defense capabilities. An example of this is the participation by the Japanese Aegis destroyer Kirishima in the successful sea-based intercept test last week in the waters of Hawaii alongside the three ships of the U.S. Navy.
MDAA also hosted its' Champion Reception event that included Hawaiian Legislators and local Community leaders prior to the international exercise in Honolulu with the Japanese delegation that included Captain Miki of the Kirishima and Rear Admiral Brad Hicks who directed the United States participation of that exercise.
Today, Missile Defense is creating stability in an unstable world that allows us to help defuse the current situation in North Korea and thus making the World a safer place.


text:
Articles tagged lenfest local lab (5)
Product teams have taken national news organizations by storm. What's happening locally?
"We're trying to create great experiences for both our friends in the newsroom and our audiences whom we never meet."
Sarah SchmalbachApril 2, 2019
Taking local news to the really local level: Using location data to deliver relevant local news
"We were glad to see hundreds of people install the app and also give it permission to access their location and motion."
Sarah SchmalbachFebruary 20, 2019
How the Lenfest Local Lab used texting to inform Philadelphians about election issues
Texting "seemed like a way to allow people to pare the constant stream of news down to just what mattered to them the most."
A referendum on media experiments? Here's what news organizations are toying with in the 2018 election cycle
People from 433 out of 435 congressional districts have signed up for ProPublica's User Guide to Democracy, reporters from the Philadelphia Inquirer and the New York Times want you to text them, and more. Christine Schmidt
Christine SchmidtAugust 23, 2018
The Lenfest Institute is testing new products for local news, and it wants your help
"If we're going to be a test kitchen, let's cook some stuff!"
Schmidt, Christine. "The Lenfest Institute is testing new products for local news, and it wants your help." Nieman Journalism Lab. Nieman Foundation for Journalism at Harvard, 23 Aug. 2018. Web. 30 Jan. 2023.
Schmidt, C. (2018, Aug. 23). The Lenfest Institute is testing new products for local news, and it wants your help. Nieman Journalism Lab. Retrieved January 30, 2023, from https://www.niemanlab.org/2018/08/the-lenfest-institute-is-testing-new-products-for-local-news-and-it-wants-your-help/
Schmidt, Christine. "The Lenfest Institute is testing new products for local news, and it wants your help." Nieman Journalism Lab. Last modified August 23, 2018. Accessed January 30, 2023. https://www.niemanlab.org/2018/08/the-lenfest-institute-is-testing-new-products-for-local-news-and-it-wants-your-help/.
| url = https://www.niemanlab.org/2018/08/the-lenfest-institute-is-testing-new-products-for-local-news-and-it-wants-your-help/
| title = The Lenfest Institute is testing new products for local news, and it wants your help
| last = Schmidt
| first = Christine
| date = 23 August 2018
| ref = {{harvid|Schmidt|2018}}