text:
2014-15 Schedule Preview - Texas A&M Aggies
Alabama will open the SEC schedule at home against the Aggies. This will be the first of two games between the two programs, as Alabama will later travel to College Station for the final game of the regular season on March 7th. A&M won the only match-up between the two last season by a score of 63-48. Like Alabama, the Aggies didn't receive much love in the preseason standings as A&M is picked to finish 9th, just in front of our beloved Crimson Tide, who are picked to finish 10th. However, I think this A&M team is intriguing and could finish a bit higher.
For starters, they return 5 of their top 8 scorers from a year ago, including a steady senior in Kourtney Roberson (6'9, 247 lbs, 9.7 ppg, 6.7 rpg) and, in my opinion, one of the more underrated players in the league in Alex Caruso (6'5, 184 lbs, 9.0 ppg, 5.0 apg, 2.0 spg). Jalen Jones (6'7, 223 lbs) is a potential impact transfer that was the leading scorer at SMU his sophomore year (14.0 ppg, 7.7 rpg). His arrival should help improve an offense that finished 13th in the conference in scoring. If Houston transfer Danuel House (12.9 ppg, 5.1 rpg) is granted a waiver to play this season, that will give A&M even more firepower.
A familiar face to SEC basketball fans will also be joining the A&M coaching staff this season with Rick Stansbury joining Billy Kennedy's staff as an assistant coach. The hire seems to have already helped in recruiting as A&M currently has a monster class (rated top 5 by some) committed for 2015. It's been a slow start for Billy Kennedy in Aggieland, but the future seems very bright if you're an A&M basketball fan.
Conference openers are always important, but this one will be vital for Alabama as their opening conference schedule will feature 3 of their first 5 games on the road, and the other home game in that stretch is against a Kentucky team that could be a colossus in the SEC this season. With that kind of schedule, a slow start in conference play could be inevitable. Which means that this opener against A&M could be considered a must-win when January 6th arrives.
Posted by MSmilie at 1:08 AM
DJC said...
To summarize, attendance is down. I think that falls clearly in the "No shit, sherlock." category.
You all know how I feel about the importance of promoting the program here. This quote is particularly troubling to me:
"As for raising his public profile, Grant doesn't seem inclined to do so.
"I'm probably a guy that is more focused on controlling the things that I can control, and that's building this program and taking care of people in this program who I need to take care of," he said. "I also have a wife and four children that I have a deep commitment to in terms of making sure that they also get some of my attention and time, that's something I value that's really important to me.
"I can't be good at everything, I can't excel at everything. I think everybody in life has to have priorities in terms of what's the most important things to them. Would I like to be able to go and speak at a lot more different things to promote our program? Certainly I would, but there's only so many hours in the day, so much time I have."
I respect that he's a good father, husband, etc., and I hate making comparisons to the football program, but can anyone imagine Coach Saban ever saying anything like that? He doesn't see promoting the program as a priority worthy of taking time away from his family. In order to win championships, sacrifices have to be made. How can Coach Grant ask the players to put in the extra time at the gym, run and work on their jump shots outside of practice, etc, if he's not willing to skip out on a Chuck E Cheese date to do a radio interview, or glad hand folks at a golf tournament, or speak to booster groups?
Perhaps this quote was taken out of context, or maybe I am misinterpreting the message he was trying to convey. I hope that I am wrong, but this certainly doesn't give me the impression that we are doing everything we can to out work our opponents.
Alias said...
Combining the money available to aTm's boosters and a recruiter like Coach $tan$field could produce a juggernaut in very short order. Look out SEC.
I too was very disappointed to read that article. I forked over the funds for season tickets again this year because I want to have good seats when we field a team that makes the trip worthwhile. I am not confident that will happen this year, but it would be nice if it did.
I get the family commitment thing, but when you are the HC at a major college school the belief is the job IS A MAJOR PART of your life. Grant seems to love that money, but not so much on the commitment. Quotes like this tells me he needs to go back to mid-major coaching or settle back into an assistant role whenever his time is up here.
2014-15 Schedule Preview - South Carolina Gamecock...
A challenge for Crimson Tide Marketing- PROMOTE TH...
2014-15 Schedule Preview - Tennessee Volunteers
Could Anyone Use My UCLA Tickets
This article right here sums up the commitment to ...
2014-15 Schedule Preview: North Florida Ospreys
BBQ and Basketball
2014-15 Schedule Preview: UCLA Bruins
Hoops on the Quad.
Christophe Varidel has left the team for medical r...
2014-15 Schedule Preview: Stillman Tigers/Appalach...
Dazon Ingram commits to Alabama
2014-15 Schedule Preview: Wichita State Shockers
2014-15 Schedule Preview: Tennessee Tech Golden Ea...
Alabama Basketball Presents "Hoops on the Quad" on...
2014-15 Schedule Preview - Xavier Musketeers
2014-15 Schedule Preview - South Florida Bulls
2014-15 Schedule Preview - Maryland Terrapins/Ariz...
2014-15 Schedule Preview - Iowa State Cyclones
2014-15 Schedule Preview - Southern Miss Golden Ea...


This was stated by the Ministry of defence of Ukraine.
"During the exercise are going to practice shooting from the "Buk-M1", s-125, s-300P / / B1. The situation will be as close to the fighting. Priority attention will be given live firing. Plan to conduct even more ambitious than last year, teaching. We are talking about combat shooting with the consolidated regiments of anti-aircraft missile "Buk-M1" and "s-300P". Division "trekstock" will cause in the area of performance training and combat missions all of a sudden, with standard weapons and military equipment. Of course, the situation will look more realistic. Namely, it is the main task", – said the head of the anti-aircraft missile troops of Ukraine Yuriy stawski.
"All States have the right to conduct exercises in the framework of their tasks. However, the fact that Ukraine holds exercises near the border with Crimea, said that provocateurs can't calm down".
In the Russian Ministry stressed that the soldiers of the army corps of the black sea fleet of the Russian Navy began classes for fire training.
"The staff performs the standards for fire training, tactics, and driving combat vehicles",- stated in the message.
In the exercises on the ranges occupied Crimea involved more than 1,000 personnel and more than 100 units of military and special equipment.
Earlier it was reported that the three factors that will destroy the Crimean bridge.
"Crimean bridge located at the junction of tectonic plates that can destroy it. The movement of these plates, will rupture the very design of this bridge.
This was partly taken into account by the construction of the bridge, since the bridge consists of three separate parts, however, in the case of major tectonic displacements will break".
"That is, those who designed, who built the bridge, have some caution," he stressed.
The second danger of the Crimean bridge are soft soils, which are support.
The third threat to the bridge – maybe the ice formed in the waters of the Kerch Strait.


In 1983 the PTO President of Bell School created a scholarship fund. This fund was created to support those children at Bell School who needed a little extra attention, whether that was through tutoring, summer camp or music lessons – things their parents may not be able to provide. This scholarship fund was created quietly and has, over the last 36 years, supported over 400 children within the Marblehead community. It has provided our Guidance Counselors with an opportunity to enhance the lives of those children and families at Bell who need just a little extra support.
In December of 2018 the PTO was contacted and asked to take over the scholarship fund. As we dove into the details of the scholarship, we were in awe of what this one woman, Mary Gately, has done to support Bell School children. Mary no longer resides in Marblehead, but has still continued to push for these children, whom she doesn't know, to be given the support they need to thrive.
We are excited to have this opportunity to continue to grow this fund and support the children of Bell School. We have renamed the fund the Mary Gately Scholarship Fund in honor of the woman who had the foresight and compassion to create a support system for our students that would still be around over 36 years later.
Some of you may have been touched by the support this fund created when you were students at Bell. Most of you have probably encountered children who have been given opportunities to learn, expand their social skills and have summer camp fun with their peers because of this fund. With over 400 Bell School children supported by this scholarship, you can imagine the impact it has made on our community.
As we move forth with the Mary Gately Scholarship Fund, we would like to ask for your support. There is a growing need to support more children and we are seeking donations to help us expand this program to more Bell students. These funds go 100% directly to students at Bell who need support. They do not go to the PTO, but to a separate fund that is specifically set-up for the Scholarship.
If you are willing to donate towards this amazing Scholarship, we would welcome any amount you can give. Checks can be made to the Mary Gately Scholarship Fund and given to the PTO via the front desk at Bell. You can also donate online below. Donations are tax-deductible.
If you have any questions, please feel free to reach out to us. We are honored to be given this opportunity to continue to support Bell School students just as Mary Gately has for almost 40 years. What an amazing Bell School Community we have and have always had!
Please Donate to the Mary Gately Scholarship Fund!


text:
copper and gold mining in southern africa
100,000 Year Old Ruins of South Africa Ancient Explorers
In fact, most of these mines have been described as gold mines, copper, tin and iron mines. In my personal experience and research I have found at least 25 ancient mine shafts in gold rich areas and been told about dozens more by farmers all over South Africa.
The World's 20 Largest Copper Mines The Balance
Jun 25, 20190183;32;The largest copper mine in Africa, Kansanshi is owned and operated by Kansanshi Mining PLC, which is 80 percent owned by a First Quantum subsidiary. The remaining 20 percent is owned by a subsidiary of ZCCM.
Copper Mining in Africa Projects IQ
Copper Mining in Africa. Copper mining in Africa predominantly stems from mining projects in the DRC (48 projects), Zambia (34 mining projects) and Namibia (21 projects) with a total of 134 copper mining projects throughout Africa. Due to its excellent conducting properties,
Hollmec Mining Limited Miners and global suppliers of
We are also one of the leading mines in southern Africa mining and supplyng Semi refined Gold with a focus on the mining, sales and marketing on a global scale . Diamond Project Hollmec Mining Limited has invested in a Diamond Deposite that is currently under construction.
Minerals and Mining in South Africa, Hluma Minerals SA
COPPER. Hluma Minerals is a major shareholder in a copper benefication plant which produces +/ 99 % pure copper in the Northern Cape and a mine. We have an offtake here in South Africa for the lifespan of projects which are estimated at 10 to 15 years . CHROME
South Africa Mining Production TRADING ECONOMICS
Mining production in South Africa shrank 1.5 percent from a year earlier in May 2019, the seventh consecutive month of decline and compared to market forecasts of a 2.5 percent slump. The largest negative contributors were gold ( 24.4 percent), diamonds ( 30.7 percent), iron ore ( 5.2 percent), and other metallic minerals ( 9.8 percent).
State of Mining in Africa In the spotlight deloitte
region. In this years edition of State of Mining in Africa In the spotlight, we take a further look at, and reflect back on, our observations to see how the broad industry is progressing. We also follow case studies that, in our view, provide good examples that support
Gold Mining in South Africa Projects IQ Homepage
Gold Mining in South Africa. Gold mining in South Africa typically involves methods such as panning, sluicing, dredging, hard rock mining, and by product mining. For most effective gold mining in South Africa, the method used is hard rock mining, since reserves are
Home Ivanhoe Mines
Ivanhoe Mines (TSX IVN; OTCQX IVPAF) is a Canadian mining company focused on advancing its three principal projects in Southern Africa the development of new mines at the Kamoa Kakula copper discovery in the Democratic Republic of Congo (DRC) and the Platreef platinum palladium nickel copper gold discovery in South Africa; and the extensive
Mineral resources South African Government
Palabora, a large copper mine, smelter and refinery complex managed by the Palabora Mining Company in Limpopo is South Africas only producer of refined copper. Producing about 80 000 t per year, it supplies most of South Africas copper needs and exports the balance.
Mining Markets in Southern Africa
The Copper Industry in Southern Africa is dominated by Zambia, the DRC and South Africa. On a smaller scale, Namibia, Botswana and Zimbabwe are also involved within this industry. The DRC overtook Zambia as Africas largest copper producer and the worlds seventh largest producer in 2013.
Gold,Copper Mines
Gold, Diamond and copper discoveries has played a major role in the economic development of East and Southern Africa states. The first recorded discovery of Gold was in
These are the top 10 Mining Companies to Work For in Africa
Anglo American. Known as one of the largest mining companies in the world, Anglo American has major assets in copper, coal, iron ore, nickel and diamonds. The company owns operations in Brazil, Chile, the United Kingdom, Australia, and South Africa
Copper in Africa
Copper is one of the world's most important industrial minerals, and Africa is an important world producer. While output is traditionally dominated by Zambia , South Africa and Katanga Province in the south of the Democratic Republic of the Congo , many African nations contribute to copper production , and many African nations have undeveloped ore resources.
South Africa World's Deepest Gold Mine Construction Full
Feb 25, 20170183;32;Mponeng is a gold mine in South Africa's Gauteng province. It extends over 4 kilometres below the surface, and is considered to be one of the most substantial gold mines in the world.
Top ten biggest gold mines mining technology
Sep 29, 20130183;32;Mponeng gold mine located near the town of Carletonville, South Africa, ranks as the tenth largest gold mine in the world. The contained gold reserve of Mponeng was estimated to be 13.81Moz (42.52Mt grading 10.10g/t gold), as of December 2012. Mponeng is owned and operated by AngloGold Ashanti.
Mining and minerals in South Africa
Aug 16, 20120183;32;With South Africas economy built on gold and diamond mining, the sector is an important foreign exchange earner, with gold accounting for more than one third of exports. In 2009, the countrys diamond industry was the fourth largest in the world. South Africa is also a major producer of coal, manganese and chrome.
Avgold Target Gold Mine Processing Plant, South Africa
Avgold Target Gold Mine Processing Plant. Fluor South Africa was awarded the design, construction, and commissioning contract for the Target Gold Project. Detailed design was carried out at Fluor's office in Perth, and responsibility for construction was transferred to the Fluor's site office at Free State, South Africa. During construction,
THE IMPACT OF MINING ON THE SOUTH AFRICAN ECONOMY
Harmony Gold, now one of South Africa's four largest gold mining companies, is spending $300 million to purchase the low cost Moab Khotsong mine from AngloGold, along with the neighbouring Great Noligwa mine and related infrastructure. Some 6 500 employees will
Pre colonial mining in southern Africa SAIMM
Pre colonial mining in southern Africa Nevertheless, there are both literature and media productions that attribute the ancient mines to foreign influences, be they Sumerian, Phoenician, Indian, Arab, or Egyptian9. The weakest part of such arguments, Herbert asserts, is that mining techniques show so little difference throughout
Minerals and Mining in South Africa SpringerLink
Mining in southern Africa has a long pre colonial history. Haematite mining in Swaziland can be traced back more than 40,000 years, iron smelting dates from 400 AD or earlier, and copper from 900 AD. The most iconic evidence for pre colonial mining are the gold artefacts from Mapungubwe dated between 1220 and 1300 AD.
List of COPPER mining companies. 24hgold
List of COPPER mining companies with access to company profiles, projects, resources and reserves and technical analysis.
Hluma Minerals Mining Company South Africa, Mining Gold
hluma minerals. Is a South African based mining,minerals processing and commodity trading company. Our head offices are in the Gauteng Province in Sandton,South Africa we mine process and trade the following comodities chrome,copper manganese,iron and gold a dedicated seasoned mining and engineering team of mostly young and previously disadvantaged professionals that see the day to day
Mining Countries of Africa
Top mining countries in Africa. Precious metals are scattered throughout Africa, from Senegal in the west to Ethiopia in the east, and South Africa in the South. Diamonds are found throughout the continent and copper is ubiquitous in the Democratic Republic of Congo, Tanzania, South Africa and Namibia.
Southern Africa Resource Watch urges govt not to sell its
Southern Africa Resource Watch urges govt not to sell its Kansanshi Copper, Gold Mine stake By Charles tembo in Ndola on February 9, 2019 THE Southern Africa Resource Watch has asked the Zambian government not to sell its 20 per cent stake a joint venture with First Quantum Minerals Kansanshi Mine.
The top ten deepest mines in the world Mining Technology
AngloGold Ashantis Mponeng gold mine, located south west of Johannesburg in South Africa, is currently the deepest mine in the world. The operating depth at Mponeng mine ranged from between 2.4km to more than 3.9km below the surface by the end of 2012. Ongoing expansions have resulted in deeper digging at Mponeng, pushing the record to beyond the four kilometre mark.
Sep 29, 20130183;32;Indonesia is home to the world's biggest gold mine while South Africa, which houses the majority of the deepest mines in the world, also hosts two of the top ten largest gold mines. Mining technology profiles the top ten biggest gold mines in the world based on contained gold reserves.
Pre:magnitogorsk gravel crusherNext:function of thickener in plants
copper flotation rate
copper oplant small scale minning
low invest copper washing plant with stable perfor
copper chrome gold processing line for sale
extractable zinc as per usp

redpajama_set_name: RedPajamaCommonCrawl


GB Immigrations appeals team are experts in representing clients, regardless of their application types. As a leading Solicitors practice, with a national presence, it allows us to deal with the most complex matters and provide legal representation for clients at the First and Upper Tier Tribunal all over the UK.
Should you have your immigration application refused, where it is permitted, the case can be appealed and heard before an independent Tribunal (called the First Tier Tribunal). In the event that is unsuccessful, a further appeal may be submitted on a point of law to the Upper Tier Tribunal. Should that also be unsuccessful, the only option left is Judicial Review proceedings.
Where indicated on the Refusal Letter, you may be provided the option to request an Administrative Review. Essentially this is the preparation and submission of grounds in writing asking for an Immigration decision to be reviewed and for the initial decision to be overturned. The review is normally carried out by a different Caseworker or Manager from the Office or Department which issued the refusal and the decision will either be upheld or amended. In the case of Entry Clearance refusals which do have a right of Appeal, the Administrative review is followed by an Appeal at the First Tier Tribunal etc.
If you have received a refusal of your application, as a matter of urgency contact our expert team. Given that all Appeals or Administrative Reviews have strict time sensitive deadlines, it is imperative to obtain good advice from the outset to protect your position.


In his lecture, Professor Maitland will describe his ground-breaking research on cancer stem cells. There is fewer than one cancer stem cell for every thousand cells in a tumour, but it is the stem cell component which is probably responsible for not only the spread of cancers around the body, but also for tumour relapse after treatment. The YCR Cancer Research Unit at the University of York, which Professor Maitland directs, has pioneered the study of these cells, and are developing drugs to eliminate the stem cell components in human prostate cancer, now the most commonly diagnosed tumour in men.
The lecture is suitable for a public audience with children aged from 13/14+.
Admission is free, but tickets are required. Light refreshments provided. To reserve tickets please email: events@stpetersyork.org.uk or phone 01904 527300.
This lecture will be held as part of Yornight. See their website.
Norman J Maitland, PhD is a graduate in Biochemistry (University of Glasgow), with a PhD in Cancer Studies (University of Birmingham). He trained as a Robertson Research Fellow in Cold Spring Harbor Laboratory and CRC Research Fellow in Genetics (University of Edinburgh). During this time his research was mainly directed towards the role of DNA tumour viruses in human cancer. In 1977 he reported the first correction of a gene defect in mammalian cells by direct gene transfer. After appointment as the first UK Lecturer in Molecular Pathology at the University of Bristol (1983-91), to develop nucleic acid technologies in the diagnosis and treatment of human disease, he determined the importance of HPV infection in human oral carcinomas, and was appointed the first Director of the CLIC Children's Cancer Research Laboratory, which described the role of genomic imprinting in tumour suppression in Wilms Tumor and the importance of gene fusions in tracking clinical disease in pediatric leukemias. In 1991 he moved to York, to become Yorkshire Cancer Research Professor of Molecular Biology and Director of the YCR Cancer Research Unit. The laboratory had two main aims: firstly to bring a structural biology approach to the understanding of protein function in oncogenic viruses, culminating in a series of papers which revealed the key role of HPV16 E2 protein-induced chromatin looping in the control of viral oncogene expression. The second aim, which is now the main focus of the laboratory, was to establish a basic biology research group to understand prostate cancer and hence to develop effective therapeutics. Current research on the basic biology of the prostate, including studies of gene expression control and therapy for human prostate cancer, is based on a stem cell paradigm, which has the CRU has now studied for more than 10 years, establishing many of the systems and hypotheses worked on around the world in this field. He is the author of more than 170 refereed papers, numerous academic articles and is a past chair of both the British Prostate Group and the European Society for Urological Research, and was awarded the Chopin prize in 2009 for research excellence in the field of prostate stem cell biology. He has coordinated and participated in a large number of EU funded research networks, researching both Gene Therapy approaches to cancer treatment, and prostate cancer biology.
In 2002, he founded a biotech company (Pro-Cure Therapeutics), to exploit the translational output of the Cancer Research Unit. He is the author of more than 40 patent applications including key granted patents for the use of prostate cancer stem cells as therapeutic targets.


I'll take them all! I'm so in love with this dress it's not even funny! This thermal runs really oversized so size down. The thermal comes in tons of colors! Actually, everything here except for the dress comes in multiple colors. Now if I can just stop myself from buying each item in every color.


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

namespace Microsoft.WindowsAzure.Storage
{
#if !(WINDOWS_RT || ASPNET_K || PORTABLE)
    using Microsoft.WindowsAzure.Storage.Analytics;
#endif
    using Microsoft.WindowsAzure.Storage.Auth;
    using Microsoft.WindowsAzure.Storage.Blob;
    using Microsoft.WindowsAzure.Storage.Core;
    using Microsoft.WindowsAzure.Storage.Core.Auth;
    using Microsoft.WindowsAzure.Storage.Core.Util;
#if !PORTABLE
    using Microsoft.WindowsAzure.Storage.File;
#endif
    using Microsoft.WindowsAzure.Storage.Queue;
    using Microsoft.WindowsAzure.Storage.Table;
    using System;
    using System.Collections.Generic;
    using System.Diagnostics.CodeAnalysis;
    using System.Globalization;
    using System.Linq;
    using AccountSetting = System.Collections.Generic.KeyValuePair<string, System.Func<string, bool>>;
    using Microsoft.WindowsAzure.Storage.Shared.Protocol;

    /// <summary>
    /// Represents a Windows Azure Storage account.
    /// </summary>
    public sealed class CloudStorageAccount
    {
        /// <summary>
        /// The FISMA compliance default value.
        /// </summary>
        private static bool version1MD5 = true;

        /// <summary>
        /// Gets or sets a value indicating whether the FISMA MD5 setting will be used.
        /// </summary>
        /// <value><c>false</c> to use the FISMA MD5 setting; <c>true</c> to use the .NET default implementation.</value>
#if WINDOWS_PHONE || PORTABLE
        internal
#else
        public
#endif
 static bool UseV1MD5
        {
            get { return version1MD5; }
            set { version1MD5 = value; }
        }

        /// <summary>
        /// The setting name for using the development storage.
        /// </summary>
        internal const string UseDevelopmentStorageSettingString = "UseDevelopmentStorage";

        /// <summary>
        /// The setting name for specifying a development storage proxy Uri.
        /// </summary>
        internal const string DevelopmentStorageProxyUriSettingString = "DevelopmentStorageProxyUri";

        /// <summary>
        /// The setting name for using the default storage endpoints with the specified protocol.
        /// </summary>
        internal const string DefaultEndpointsProtocolSettingString = "DefaultEndpointsProtocol";

        /// <summary>
        /// The setting name for the account name.
        /// </summary>
        internal const string AccountNameSettingString = "AccountName";

        /// <summary>
        /// The setting name for the account key name.
        /// </summary>
        internal const string AccountKeyNameSettingString = "AccountKeyName";

        /// <summary>
        /// The setting name for the account key.
        /// </summary>
        internal const string AccountKeySettingString = "AccountKey";

        /// <summary>
        /// The setting name for a custom blob storage endpoint.
        /// </summary>
        internal const string BlobEndpointSettingString = "BlobEndpoint";

        /// <summary>
        /// The setting name for a custom queue endpoint.
        /// </summary>
        internal const string QueueEndpointSettingString = "QueueEndpoint";

        /// <summary>
        /// The setting name for a custom table storage endpoint.
        /// </summary>
        internal const string TableEndpointSettingString = "TableEndpoint";

        /// <summary>
        /// The setting name for a custom file storage endpoint.
        /// </summary>
        internal const string FileEndpointSettingString = "FileEndpoint";

        /// <summary>
        /// The setting name for a custom storage endpoint suffix.
        /// </summary>
        internal const string EndpointSuffixSettingString = "EndpointSuffix";

        /// <summary>
        /// The setting name for a shared access key.
        /// </summary>
        internal const string SharedAccessSignatureSettingString = "SharedAccessSignature";

        /// <summary>
        /// The default account name for the development storage.
        /// </summary>
        private const string DevstoreAccountName = "devstoreaccount1";

        /// <summary>
        /// The default account key for the development storage.
        /// </summary>
        private const string DevstoreAccountKey = "Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==";

        /// <summary>
        /// The suffix appended to account in order to access secondary location for read only access.
        /// </summary>
        internal const string SecondaryLocationAccountSuffix = "-secondary";

        /// <summary>
        /// The default storage service hostname suffix.
        /// </summary>
        private const string DefaultEndpointSuffix = "core.windows.net";

        /// <summary>
        /// The default blob storage DNS hostname prefix.
        /// </summary>
        private const string DefaultBlobHostnamePrefix = "blob";

        /// <summary>
        /// The root queue DNS name prefix.
        /// </summary>
        private const string DefaultQueueHostnamePrefix = "queue";

        /// <summary>
        /// The root table storage DNS name prefix.
        /// </summary>
        private const string DefaultTableHostnamePrefix = "table";

        /// <summary>
        /// The default file storage DNS hostname prefix.
        /// </summary>
        private const string DefaultFileHostnamePrefix = "file";

        /// <summary>
        /// Validator for the UseDevelopmentStorage setting. Must be "true".
        /// </summary>
        private static readonly AccountSetting UseDevelopmentStorageSetting = Setting(UseDevelopmentStorageSettingString, "true");

        /// <summary>
        /// Validator for the DevelopmentStorageProxyUri setting. Must be a valid Uri.
        /// </summary>
        private static readonly AccountSetting DevelopmentStorageProxyUriSetting = Setting(DevelopmentStorageProxyUriSettingString, IsValidUri);

        /// <summary>
        /// Validator for the DefaultEndpointsProtocol setting. Must be either "http" or "https".
        /// </summary>
        private static readonly AccountSetting DefaultEndpointsProtocolSetting = Setting(DefaultEndpointsProtocolSettingString, "http", "https");

        /// <summary>
        /// Validator for the AccountName setting. No restrictions.
        /// </summary>
        private static readonly AccountSetting AccountNameSetting = Setting(AccountNameSettingString);

        /// <summary>
        /// Validator for the AccountKey setting. No restrictions.
        /// </summary>
        private static readonly AccountSetting AccountKeyNameSetting = Setting(AccountKeyNameSettingString);

        /// <summary>
        /// Validator for the AccountKey setting. Must be a valid base64 string.
        /// </summary>
        private static readonly AccountSetting AccountKeySetting = Setting(AccountKeySettingString, IsValidBase64String);

        /// <summary>
        /// Validator for the BlobEndpoint setting. Must be a valid Uri.
        /// </summary>
        private static readonly AccountSetting BlobEndpointSetting = Setting(BlobEndpointSettingString, IsValidUri);

        /// <summary>
        /// Validator for the QueueEndpoint setting. Must be a valid Uri.
        /// </summary>
        private static readonly AccountSetting QueueEndpointSetting = Setting(QueueEndpointSettingString, IsValidUri);

        /// <summary>
        /// Validator for the TableEndpoint setting. Must be a valid Uri.
        /// </summary>
        private static readonly AccountSetting TableEndpointSetting = Setting(TableEndpointSettingString, IsValidUri);

        /// <summary>
        /// Validator for the FileEndpoint setting. Must be a valid Uri.
        /// </summary>
        private static readonly AccountSetting FileEndpointSetting = Setting(FileEndpointSettingString, IsValidUri);

        /// <summary>
        /// Validator for the EndpointSuffix setting. Must be a valid Uri.
        /// </summary>
        private static readonly AccountSetting EndpointSuffixSetting = Setting(EndpointSuffixSettingString, IsValidDomain);

        /// <summary>
        /// Validator for the SharedAccessSignature setting. No restrictions.
        /// </summary>
        private static readonly AccountSetting SharedAccessSignatureSetting = Setting(SharedAccessSignatureSettingString);

#if !PORTABLE
        /// <summary>
        /// Singleton instance for the development storage account.
        /// </summary>
        private static CloudStorageAccount devStoreAccount;
#endif

        /// <summary>
        /// Initializes a new instance of the <see cref="CloudStorageAccount"/> class using the specified
        /// credentials and service endpoints.
        /// </summary>
        /// <param name="storageCredentials">A <see cref="StorageCredentials"/> object.</param>
        /// <param name="blobEndpoint">A <see cref="System.Uri"/> specifying the primary Blob service endpoint.</param>
        /// <param name="queueEndpoint">A <see cref="System.Uri"/> specifying the primary Queue service endpoint.</param>
        /// <param name="tableEndpoint">A <see cref="System.Uri"/> specifying the primary Table service endpoint.</param>
        /// <param name="fileEndpoint">A <see cref="System.Uri"/> specifying the primary File service endpoint.</param>
        public CloudStorageAccount(StorageCredentials storageCredentials, Uri blobEndpoint, Uri queueEndpoint, Uri tableEndpoint, Uri fileEndpoint)
            : this(storageCredentials, new StorageUri(blobEndpoint), new StorageUri(queueEndpoint), new StorageUri(tableEndpoint), new StorageUri(fileEndpoint))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="CloudStorageAccount"/> class using the specified
        /// account credentials and service endpoints.
        /// </summary>
        /// <param name="storageCredentials">A <see cref="StorageCredentials"/> object.</param>
        /// <param name="blobStorageUri">A <see cref="StorageUri"/> specifying the Blob service endpoint or endpoints.</param>
        /// <param name="queueStorageUri">A <see cref="StorageUri"/> specifying the Queue service endpoint or endpoints.</param>
        /// <param name="tableStorageUri">A <see cref="StorageUri"/> specifying the Table service endpoint or endpoints.</param>
        /// <param name="fileStorageUri">A <see cref="StorageUri"/> specifying the File service endpoint or endpoints.</param>
#if WINDOWS_RT
        /// <returns>A <see cref="CloudStorageAccount"/> instance for the specific credentials and service endpoints.</returns>
        public static CloudStorageAccount Create(StorageCredentials storageCredentials, StorageUri blobStorageUri, StorageUri queueStorageUri, StorageUri tableStorageUri, StorageUri fileStorageUri)
        {
            return new CloudStorageAccount(storageCredentials, blobStorageUri, queueStorageUri, tableStorageUri, fileStorageUri);
        }

        private CloudStorageAccount(StorageCredentials storageCredentials, StorageUri blobStorageUri, StorageUri queueStorageUri, StorageUri tableStorageUri, StorageUri fileStorageUri)
#else
        public CloudStorageAccount(StorageCredentials storageCredentials, StorageUri blobStorageUri, StorageUri queueStorageUri, StorageUri tableStorageUri, StorageUri fileStorageUri)
#endif
        {
            this.Credentials = storageCredentials;
            this.BlobStorageUri = blobStorageUri;
            this.QueueStorageUri = queueStorageUri;
            this.TableStorageUri = tableStorageUri;
            this.FileStorageUri = fileStorageUri;
            this.DefaultEndpoints = false;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="CloudStorageAccount"/> class using the specified
        /// credentials, and specifies whether to use HTTP or HTTPS to connect to the storage services.
        /// </summary>
        /// <param name="storageCredentials">A <see cref="StorageCredentials"/> object.</param>
        /// <param name="useHttps"><c>true</c> to use HTTPS to connect to storage service endpoints; otherwise, <c>false</c>.</param>
        /// <remarks>Using HTTPS to connect to the storage services is recommended.</remarks>
        public CloudStorageAccount(StorageCredentials storageCredentials, bool useHttps)
            : this(storageCredentials, null /* endpointSuffix */, useHttps)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="CloudStorageAccount"/> class using the specified
        /// credentials and endpoint suffix, and specifies whether to use HTTP or HTTPS to connect to the storage services.
        /// </summary>
        /// <param name="storageCredentials">A <see cref="StorageCredentials"/> object.</param>
        /// <param name="endpointSuffix">The DNS endpoint suffix for all storage services, e.g. "core.windows.net".</param>
        /// <param name="useHttps"><c>true</c> to use HTTPS to connect to storage service endpoints; otherwise, <c>false</c>.</param>
        /// <remarks>Using HTTPS to connect to the storage services is recommended.</remarks>
        public CloudStorageAccount(StorageCredentials storageCredentials, string endpointSuffix, bool useHttps)
            : this(storageCredentials, storageCredentials == null ? null : storageCredentials.AccountName, endpointSuffix, useHttps)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="CloudStorageAccount"/> class using the specified
        /// credentials and endpoint suffix, and specifies whether to use HTTP or HTTPS to connect to the storage services.
        /// </summary>
        /// <param name="storageCredentials">A <see cref="StorageCredentials"/> object.</param>
        /// <param name="accountName">The name of the account.</param>
        /// <param name="endpointSuffix">The DNS endpoint suffix for all storage services, e.g. "core.windows.net".</param>
        /// <param name="useHttps"><c>true</c> to use HTTPS to connect to storage service endpoints; otherwise, <c>false</c>.</param>
        /// <remarks>Using HTTPS to connect to the storage services is recommended.</remarks>
        public CloudStorageAccount(StorageCredentials storageCredentials, string accountName, string endpointSuffix, bool useHttps)
        {
            CommonUtility.AssertNotNull("storageCredentials", storageCredentials);
            if (!string.IsNullOrEmpty(storageCredentials.AccountName))
            {
                if (string.IsNullOrEmpty(accountName))
                {
                    accountName = storageCredentials.AccountName;
                }
                else
                {
                    if (string.Compare(storageCredentials.AccountName, accountName, System.StringComparison.Ordinal) != 0)
                    {
                        throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, SR.AccountNameMismatch, storageCredentials.AccountName, accountName));
                    }
                }
            }

            CommonUtility.AssertNotNull("AccountName", accountName);

            string protocol = useHttps ? "https" : "http";
            this.BlobStorageUri = ConstructBlobEndpoint(protocol, accountName, endpointSuffix);
            this.QueueStorageUri = ConstructQueueEndpoint(protocol, accountName, endpointSuffix);
            this.TableStorageUri = ConstructTableEndpoint(protocol, accountName, endpointSuffix);
            this.FileStorageUri = ConstructFileEndpoint(protocol, accountName, endpointSuffix);
            this.Credentials = storageCredentials;
            this.EndpointSuffix = endpointSuffix;
            this.DefaultEndpoints = true;
        }

#if !PORTABLE
        /// <summary>
        /// Gets a <see cref="CloudStorageAccount"/> object that references the well-known development storage account.
        /// </summary>
        /// <value>A <see cref="CloudStorageAccount"/> object representing the development storage account.</value>
        public static CloudStorageAccount DevelopmentStorageAccount
        {
            get
            {
                if (devStoreAccount == null)
                {
                    devStoreAccount = GetDevelopmentStorageAccount(null);
                }

                return devStoreAccount;
            }
        }
#endif

        /// <summary>
        /// Indicates whether this account is a development storage account.
        /// </summary>
        private bool IsDevStoreAccount { get; set; }

        /// <summary>
        /// The storage service hostname suffix set by the user, if any.
        /// </summary>
        private string EndpointSuffix { get; set; }

        /// <summary>
        /// The connection string parsed into settings.
        /// </summary>
        private IDictionary<string, string> Settings { get; set; }

        /// <summary>
        /// True if the user used a constructor that auto-generates endpoints.
        /// </summary>
        private bool DefaultEndpoints { get; set; }

        /// <summary>
        /// Gets the primary endpoint for the Blob service, as configured for the storage account.
        /// </summary>
        /// <value>A <see cref="System.Uri"/> containing the primary Blob service endpoint.</value>
        public Uri BlobEndpoint
        {
            get
            {
                if (this.BlobStorageUri == null)
                {
                    return null;
                }

                return this.BlobStorageUri.PrimaryUri;
            }
        }

        /// <summary>
        /// Gets the primary endpoint for the Queue service, as configured for the storage account.
        /// </summary>
        /// <value>A <see cref="System.Uri"/> containing the primary Queue service endpoint.</value>
        public Uri QueueEndpoint
        {
            get
            {
                if (this.QueueStorageUri == null)
                {
                    return null;
                }

                return this.QueueStorageUri.PrimaryUri;
            }
        }

        /// <summary>
        /// Gets the primary endpoint for the Table service, as configured for the storage account.
        /// </summary>
        /// <value>A <see cref="System.Uri"/> containing the primary Table service endpoint.</value>
        public Uri TableEndpoint
        {
            get
            {
                if (this.TableStorageUri == null)
                {
                    return null;
                }

                return this.TableStorageUri.PrimaryUri;
            }
        }

        /// <summary>
        /// Gets the primary endpoint for the File service, as configured for the storage account.
        /// </summary>
        /// <value>A <see cref="System.Uri"/> containing the primary File service endpoint.</value>
        public Uri FileEndpoint
        {
            get
            {
                if (this.FileStorageUri == null)
                {
                    return null;
                }

                return this.FileStorageUri.PrimaryUri;
            }
        }

        /// <summary>
        /// Gets the endpoints for the Blob service at the primary and secondary location, as configured for the storage account.
        /// </summary>
        /// <value>A <see cref="StorageUri"/> containing the Blob service endpoints.</value>
        public StorageUri BlobStorageUri { get; private set; }

        /// <summary>
        /// Gets the endpoints for the Queue service at the primary and secondary location, as configured for the storage account.
        /// </summary>
        /// <value>A <see cref="StorageUri"/> containing the Queue service endpoints.</value>
        public StorageUri QueueStorageUri { get; private set; }

        /// <summary>
        /// Gets the endpoints for the Table service at the primary and secondary location, as configured for the storage account.
        /// </summary>
        /// <value>A <see cref="StorageUri"/> containing the Table service endpoints.</value>
        public StorageUri TableStorageUri { get; private set; }

        /// <summary>
        /// Gets the endpoints for the File service at the primary and secondary location, as configured for the storage account.
        /// </summary>
        /// <value>A <see cref="StorageUri"/> containing the File service endpoints.</value>
        public StorageUri FileStorageUri { get; private set; }

        /// <summary>
        /// Gets the credentials used to create this <see cref="CloudStorageAccount"/> object.
        /// </summary>
        /// <value>A <see cref="StorageCredentials"/> object.</value>
        public StorageCredentials Credentials { get; private set; }

        /// <summary>
        /// Parses a connection string and returns a <see cref="CloudStorageAccount"/> created
        /// from the connection string.
        /// </summary>
        /// <param name="connectionString">A valid connection string.</param>
        /// <exception cref="ArgumentNullException">Thrown if <paramref name="connectionString"/> is null or empty.</exception>
        /// <exception cref="FormatException">Thrown if <paramref name="connectionString"/> is not a valid connection string.</exception>
        /// <exception cref="ArgumentException">Thrown if <paramref name="connectionString"/> cannot be parsed.</exception>
        /// <returns>A <see cref="CloudStorageAccount"/> object constructed from the values provided in the connection string.</returns>
        public static CloudStorageAccount Parse(string connectionString)
        {
            CloudStorageAccount ret;

            if (string.IsNullOrEmpty(connectionString))
            {
                throw new ArgumentNullException("connectionString");
            }

            if (ParseImpl(connectionString, out ret, err => { throw new FormatException(err); }))
            {
                return ret;
            }

            throw new ArgumentException(SR.ParseError);
        }

        /// <summary>
        /// Indicates whether a connection string can be parsed to return a <see cref="CloudStorageAccount"/> object.
        /// </summary>
        /// <param name="connectionString">The connection string to parse.</param>
        /// <param name="account">A <see cref="CloudStorageAccount"/> object to hold the instance returned if
        /// the connection string can be parsed.</param>
        /// <returns><b>true</b> if the connection string was successfully parsed; otherwise, <b>false</b>.</returns>
        public static bool TryParse(string connectionString, out CloudStorageAccount account)
        {
            if (string.IsNullOrEmpty(connectionString))
            {
                account = null;
                return false;
            }

            try
            {
                return ParseImpl(connectionString, out account, err => { });
            }
            catch (Exception)
            {
                account = null;
                return false;
            }
        }

        /// <summary>
        /// Creates the Table service client.
        /// </summary>
        /// <returns>A <see cref="CloudTableClient"/> object.</returns>
        public CloudTableClient CreateCloudTableClient()
        {
            if (this.TableEndpoint == null)
            {
                throw new InvalidOperationException(SR.TableEndPointNotConfigured);
            }

            if (this.Credentials == null)
            {
                throw new InvalidOperationException(SR.MissingCredentials);
            }

            return new CloudTableClient(this.TableStorageUri, this.Credentials);
        }

        /// <summary>
        /// Creates the Queue service client.
        /// </summary>
        /// <returns>A <see cref="CloudQueueClient"/> object.</returns>
        public CloudQueueClient CreateCloudQueueClient()
        {
            if (this.QueueEndpoint == null)
            {
                throw new InvalidOperationException(SR.QueueEndPointNotConfigured);
            }

            if (this.Credentials == null)
            {
                throw new InvalidOperationException(SR.MissingCredentials);
            }

            return new CloudQueueClient(this.QueueStorageUri, this.Credentials);
        }

        /// <summary>
        /// Creates the Blob service client.
        /// </summary>
        /// <returns>A <see cref="CloudBlobClient"/> object.</returns>
        public CloudBlobClient CreateCloudBlobClient()
        {
            if (this.BlobEndpoint == null)
            {
                throw new InvalidOperationException(SR.BlobEndPointNotConfigured);
            }

            return new CloudBlobClient(this.BlobStorageUri, this.Credentials);
        }

#if !(WINDOWS_RT || ASPNET_K || PORTABLE)
        /// <summary>
        /// Creates an analytics client.
        /// </summary>
        /// <returns>A <see cref="CloudAnalyticsClient"/> object.</returns>
        public CloudAnalyticsClient CreateCloudAnalyticsClient()
        {
            if (this.BlobEndpoint == null)
            {
                throw new InvalidOperationException(SR.BlobEndPointNotConfigured);
            }

            if (this.TableEndpoint == null)
            {
                throw new InvalidOperationException(SR.TableEndPointNotConfigured);
            }

            if (this.Credentials == null)
            {
                throw new InvalidOperationException(SR.MissingCredentials);
            }

            return new CloudAnalyticsClient(this.BlobStorageUri, this.TableStorageUri, this.Credentials);
        }
#endif

#if !PORTABLE
        /// <summary>
        /// Creates the File service client.
        /// </summary>
        /// <returns>A client object that specifies the File service endpoint.</returns>
        public CloudFileClient CreateCloudFileClient()
        {
            if (this.FileEndpoint == null)
            {
                throw new InvalidOperationException(SR.FileEndPointNotConfigured);
            }

            if (this.Credentials == null)
            {
                throw new InvalidOperationException(SR.MissingCredentials);
            }

            return new CloudFileClient(this.FileStorageUri, this.Credentials);
        }

        /// <summary>
        /// Returns a shared access signature for the account.
        /// </summary>
        /// <param name="policy">A <see cref="SharedAccessAccountPolicy"/> object specifying the access policy for the shared access signature.</param>
        /// <returns>A shared access signature, as a URI query string.</returns>
        /// <remarks>The query string returned includes the leading question mark.</remarks>
        public string GetSharedAccessSignature(SharedAccessAccountPolicy policy)
        {
            if (!this.Credentials.IsSharedKey)
            {
                string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.CannotCreateSASWithoutAccountKey);
                throw new InvalidOperationException(errorMessage);
            }

            string signature = SharedAccessSignatureHelper.GetHash(policy, this.Credentials.AccountName, Constants.HeaderConstants.TargetStorageVersion, this.Credentials.Key.KeyValue);
            UriQueryBuilder builder = SharedAccessSignatureHelper.GetSignature(policy, signature, this.Credentials.Key.KeyName, Constants.HeaderConstants.TargetStorageVersion);
            return builder.ToString();
        }
#endif

        /// <summary>
        /// Returns a connection string for this storage account, without sensitive data.
        /// </summary>
        /// <returns>A connection string.</returns>
        public override string ToString()
        {
            return this.ToString(false);
        }

        /// <summary>
        /// Returns a connection string for the storage account, optionally with sensitive data.
        /// </summary>
        /// <param name="exportSecrets"><c>True</c> to include sensitive data in the string; otherwise, <c>false</c>.</param>
        /// <returns>A connection string.</returns>
        public string ToString(bool exportSecrets)
        {
            if (this.Settings == null)
            {
                this.Settings = new Dictionary<string, string>();

                if (this.DefaultEndpoints)
                {
                    this.Settings.Add(DefaultEndpointsProtocolSettingString, this.BlobEndpoint.Scheme);

                    if (this.EndpointSuffix != null)
                    {
                        this.Settings.Add(EndpointSuffixSettingString, this.EndpointSuffix);
                    }
                }
                else
                {
                    if (this.BlobEndpoint != null)
                    {
                        this.Settings.Add(BlobEndpointSettingString, this.BlobEndpoint.ToString());
                    }

                    if (this.QueueEndpoint != null)
                    {
                        this.Settings.Add(QueueEndpointSettingString, this.QueueEndpoint.ToString());
                    }

                    if (this.TableEndpoint != null)
                    {
                        this.Settings.Add(TableEndpointSettingString, this.TableEndpoint.ToString());
                    }

                    if (this.FileEndpoint != null)
                    {
                        this.Settings.Add(FileEndpointSettingString, this.FileEndpoint.ToString());
                    }
                }
            }

            List<string> listOfSettings = this.Settings.Select(pair => string.Format(CultureInfo.InvariantCulture, "{0}={1}", pair.Key, pair.Value)).ToList();

            if (this.Credentials != null && !this.IsDevStoreAccount)
            {
                listOfSettings.Add(this.Credentials.ToString(exportSecrets));
            }

            return string.Join(";", listOfSettings);
        }

#if !PORTABLE
        /// <summary>
        /// Returns a <see cref="CloudStorageAccount"/> with development storage credentials using the specified proxy Uri.
        /// </summary>
        /// <param name="proxyUri">The proxy endpoint to use.</param>
        /// <returns>The new <see cref="CloudStorageAccount"/>.</returns>
        private static CloudStorageAccount GetDevelopmentStorageAccount(Uri proxyUri)
        {
            UriBuilder builder = proxyUri != null ?
                new UriBuilder(proxyUri.Scheme, proxyUri.Host) :
                new UriBuilder("http", "127.0.0.1");

            builder.Path = DevstoreAccountName;

            builder.Port = 10000;
            Uri blobEndpoint = builder.Uri;

            builder.Port = 10001;
            Uri queueEndpoint = builder.Uri;

            builder.Port = 10002;
            Uri tableEndpoint = builder.Uri;

            builder.Path = DevstoreAccountName + SecondaryLocationAccountSuffix;

            builder.Port = 10000;
            Uri blobSecondaryEndpoint = builder.Uri;

            builder.Port = 10001;
            Uri queueSecondaryEndpoint = builder.Uri;

            builder.Port = 10002;
            Uri tableSecondaryEndpoint = builder.Uri;

            StorageCredentials credentials = new StorageCredentials(DevstoreAccountName, DevstoreAccountKey);
            CloudStorageAccount account = new CloudStorageAccount(
                credentials,
                new StorageUri(blobEndpoint, blobSecondaryEndpoint),
                new StorageUri(queueEndpoint, queueSecondaryEndpoint),
                new StorageUri(tableEndpoint, tableSecondaryEndpoint),
                null /* fileStorageUri */);

            account.Settings = new Dictionary<string, string>();
            account.Settings.Add(UseDevelopmentStorageSettingString, "true");
            if (proxyUri != null)
            {
                account.Settings.Add(DevelopmentStorageProxyUriSettingString, proxyUri.ToString());
            }

            account.IsDevStoreAccount = true;

            return account;
        }
#endif

        /// <summary>
        /// Internal implementation of Parse/TryParse.
        /// </summary>
        /// <param name="connectionString">The string to parse.</param>
        /// <param name="accountInformation">The <see cref="CloudStorageAccount"/> to return.</param>
        /// <param name="error">A callback for reporting errors.</param>
        /// <returns>If true, the parse was successful. Otherwise, false.</returns>
        internal static bool ParseImpl(string connectionString, out CloudStorageAccount accountInformation, Action<string> error)
        {
            IDictionary<string, string> settings = ParseStringIntoSettings(connectionString, error);

            // malformed settings string
            if (settings == null)
            {
                accountInformation = null;

                return false;
            }

#if !PORTABLE
            // devstore case
            if (MatchesSpecification(
                settings,
                AllRequired(UseDevelopmentStorageSetting),
                Optional(DevelopmentStorageProxyUriSetting)))
            {
                string proxyUri = null;
                if (settings.TryGetValue(DevelopmentStorageProxyUriSettingString, out proxyUri))
                {
                    accountInformation = GetDevelopmentStorageAccount(new Uri(proxyUri));
                }
                else
                {
                    accountInformation = DevelopmentStorageAccount;
                }

                accountInformation.Settings = ValidCredentials(settings);
                return true;
            }
#endif

            // automatic case
            if (MatchesSpecification(
                settings,
                AllRequired(DefaultEndpointsProtocolSetting, AccountNameSetting, AccountKeySetting),
                Optional(BlobEndpointSetting, QueueEndpointSetting, TableEndpointSetting, FileEndpointSetting, AccountKeyNameSetting, EndpointSuffixSetting)))
            {
                string blobEndpoint = null;
                settings.TryGetValue(BlobEndpointSettingString, out blobEndpoint);

                string queueEndpoint = null;
                settings.TryGetValue(QueueEndpointSettingString, out queueEndpoint);

                string tableEndpoint = null;
                settings.TryGetValue(TableEndpointSettingString, out tableEndpoint);

                string fileEndpoint = null;
                settings.TryGetValue(FileEndpointSettingString, out fileEndpoint);

                accountInformation = new CloudStorageAccount(
                    GetCredentials(settings),
                    blobEndpoint != null ? new StorageUri(new Uri(blobEndpoint)) : ConstructBlobEndpoint(settings),
                    queueEndpoint != null ? new StorageUri(new Uri(queueEndpoint)) : ConstructQueueEndpoint(settings),
                    tableEndpoint != null ? new StorageUri(new Uri(tableEndpoint)) : ConstructTableEndpoint(settings),
                    fileEndpoint != null ? new StorageUri(new Uri(fileEndpoint)) : ConstructFileEndpoint(settings));

                string endpointSuffix = null;
                if (settings.TryGetValue(EndpointSuffixSettingString, out endpointSuffix))
                {
                    accountInformation.EndpointSuffix = endpointSuffix;
                }

                accountInformation.Settings = ValidCredentials(settings);
                return true;
            }

            // explicit case
            if (MatchesSpecification(
                settings,
                AtLeastOne(BlobEndpointSetting, QueueEndpointSetting, TableEndpointSetting, FileEndpointSetting),
                ValidCredentials))
            {
                Uri blobUri = !settings.ContainsKey(BlobEndpointSettingString) || settings[BlobEndpointSettingString] == null ? null : new Uri(settings[BlobEndpointSettingString]);
                Uri queueUri = !settings.ContainsKey(QueueEndpointSettingString) || settings[QueueEndpointSettingString] == null ? null : new Uri(settings[QueueEndpointSettingString]);
                Uri tableUri = !settings.ContainsKey(TableEndpointSettingString) || settings[TableEndpointSettingString] == null ? null : new Uri(settings[TableEndpointSettingString]);
                Uri fileUri = !settings.ContainsKey(FileEndpointSettingString) || settings[FileEndpointSettingString] == null ? null : new Uri(settings[FileEndpointSettingString]);

                accountInformation = new CloudStorageAccount(GetCredentials(settings), blobUri, queueUri, tableUri, fileUri);

                accountInformation.Settings = ValidCredentials(settings);
                return true;
            }

            // not valid
            accountInformation = null;

            error("No valid combination of account information found.");

            return false;
        }

        /// <summary>
        /// Tokenizes input and stores name value pairs.
        /// </summary>
        /// <param name="connectionString">The string to parse.</param>
        /// <param name="error">Error reporting delegate.</param>
        /// <returns>Tokenized collection.</returns>
        private static IDictionary<string, string> ParseStringIntoSettings(string connectionString, Action<string> error)
        {
            IDictionary<string, string> settings = new Dictionary<string, string>();
            string[] splitted = connectionString.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);

            foreach (string nameValue in splitted)
            {
                string[] splittedNameValue = nameValue.Split(new char[] { '=' }, 2);

                if (splittedNameValue.Length != 2)
                {
                    error("Settings must be of the form \"name=value\".");
                    return null;
                }

                if (settings.ContainsKey(splittedNameValue[0]))
                {
                    error(string.Format(CultureInfo.InvariantCulture, "Duplicate setting '{0}' found.", splittedNameValue[0]));
                    return null;
                }

                settings.Add(splittedNameValue[0], splittedNameValue[1]);
            }

            return settings;
        }

        /// <summary>
        /// Encapsulates a validation rule for an enumeration based account setting.
        /// </summary>
        /// <param name="name">The name of the setting.</param>
        /// <param name="validValues">A list of valid values for the setting.</param>
        /// <returns>An <see cref="AccountSetting"/> representing the enumeration constraint.</returns>
        private static AccountSetting Setting(string name, params string[] validValues)
        {
            return new AccountSetting(
                name,
                (settingValue) =>
                {
                    if (validValues.Length == 0)
                    {
                        return true;
                    }

                    return validValues.Contains(settingValue);
                });
        }

        /// <summary>
        /// Encapsulates a validation rule using a func.
        /// </summary>
        /// <param name="name">The name of the setting.</param>
        /// <param name="isValid">A func that determines if the value is valid.</param>
        /// <returns>An <see cref="AccountSetting"/> representing the constraint.</returns>
        private static AccountSetting Setting(string name, Func<string, bool> isValid)
        {
            return new AccountSetting(name, isValid);
        }

        /// <summary>
        /// Determines whether the specified setting value is a valid base64 string.
        /// </summary>
        /// <param name="settingValue">The setting value.</param>
        /// <returns><c>true</c> if the specified setting value is a valid base64 string; otherwise, <c>false</c>.</returns>
        private static bool IsValidBase64String(string settingValue)
        {
            try
            {
                Convert.FromBase64String(settingValue);

                return true;
            }
            catch (FormatException)
            {
                return false;
            }
        }

        /// <summary>
        /// Validation function that validates Uris.
        /// </summary>
        /// <param name="settingValue">Value to validate.</param>
        /// <returns><c>true</c> if the specified setting value is a valid Uri; otherwise, <c>false</c>.</returns>
        private static bool IsValidUri(string settingValue)
        {
            return Uri.IsWellFormedUriString(settingValue, UriKind.Absolute);
        }

        /// <summary>
        /// Validation function that validates a domain name.
        /// </summary>
        /// <param name="settingValue">Value to validate.</param>
        /// <returns><c>true</c> if the specified setting value is a valid domain; otherwise, <c>false</c>.</returns>
        private static bool IsValidDomain(string settingValue)
        {
            return Uri.CheckHostName(settingValue).Equals(UriHostNameType.Dns);
        }

        /// <summary>
        /// Settings filter that requires all specified settings be present and valid.
        /// </summary>
        /// <param name="requiredSettings">A list of settings that must be present.</param>
        /// <returns>The remaining settings or <c>null</c> if the filter's requirement is not satisfied.</returns>
        private static Func<IDictionary<string, string>, IDictionary<string, string>> AllRequired(params AccountSetting[] requiredSettings)
        {
            return (settings) =>
            {
                IDictionary<string, string> result = new Dictionary<string, string>(settings);

                foreach (AccountSetting requirement in requiredSettings)
                {
                    string value;
                    if (result.TryGetValue(requirement.Key, out value) && requirement.Value(value))
                    {
                        result.Remove(requirement.Key);
                    }
                    else
                    {
                        return null;
                    }
                }

                return result;
            };
        }

        /// <summary>
        /// Settings filter that removes optional values.
        /// </summary>
        /// <param name="optionalSettings">A list of settings that are optional.</param>
        /// <returns>The remaining settings or <c>null</c> if the filter's requirement is not satisfied.</returns>
        private static Func<IDictionary<string, string>, IDictionary<string, string>> Optional(params AccountSetting[] optionalSettings)
        {
            return (settings) =>
            {
                IDictionary<string, string> result = new Dictionary<string, string>(settings);

                foreach (AccountSetting requirement in optionalSettings)
                {
                    string value;
                    if (result.TryGetValue(requirement.Key, out value) && requirement.Value(value))
                    {
                        result.Remove(requirement.Key);
                    }
                }

                return result;
            };
        }

        /// <summary>
        /// Settings filter that ensures that at least one setting is present.
        /// </summary>
        /// <param name="atLeastOneSettings">A list of settings of which one must be present.</param>
        /// <returns>The remaining settings or <c>null</c> if the filter's requirement is not satisfied.</returns>
        [SuppressMessage("StyleCop.CSharp.NamingRules", "SA1305:FieldNamesMustNotUseHungarianNotation", Justification = "Reviewed.")]
        private static Func<IDictionary<string, string>, IDictionary<string, string>> AtLeastOne(params AccountSetting[] atLeastOneSettings)
        {
            return (settings) =>
            {
                IDictionary<string, string> result = new Dictionary<string, string>(settings);
                bool foundOne = false;

                foreach (AccountSetting requirement in atLeastOneSettings)
                {
                    string value;
                    if (result.TryGetValue(requirement.Key, out value) && requirement.Value(value))
                    {
                        result.Remove(requirement.Key);
                        foundOne = true;
                    }
                }

                return foundOne ? result : null;
            };
        }

        /// <summary>
        /// Settings filter that ensures that a valid combination of credentials is present.
        /// </summary>
        /// <returns>The remaining settings or <c>null</c> if the filter's requirement is not satisfied.</returns>
        private static IDictionary<string, string> ValidCredentials(IDictionary<string, string> settings)
        {
            string accountName;
            string accountKey;
            string accountKeyName;
            string sharedAccessSignature;
            IDictionary<string, string> result = new Dictionary<string, string>(settings);

            if (settings.TryGetValue(AccountNameSettingString, out accountName) &&
                !AccountNameSetting.Value(accountName))
            {
                return null;
            }

            if (settings.TryGetValue(AccountKeySettingString, out accountKey) &&
                !AccountKeySetting.Value(accountKey))
            {
                return null;
            }

            if (settings.TryGetValue(AccountKeyNameSettingString, out accountKeyName) &&
                !AccountKeyNameSetting.Value(accountKeyName))
            {
                return null;
            }

            if (settings.TryGetValue(SharedAccessSignatureSettingString, out sharedAccessSignature) &&
                !SharedAccessSignatureSetting.Value(sharedAccessSignature))
            {
                return null;
            }

            result.Remove(AccountNameSettingString);
            result.Remove(AccountKeySettingString);
            result.Remove(AccountKeyNameSettingString);
            result.Remove(SharedAccessSignatureSettingString);

            // AccountAndKey
            if (accountName != null && accountKey != null && sharedAccessSignature == null)
            {
                return result;
            }

            // SharedAccessSignature
            if (accountName == null && accountKey == null && accountKeyName == null && sharedAccessSignature != null)
            {
                return result;
            }

            // Anonymous
            if (accountName == null && accountKey == null && accountKeyName == null && sharedAccessSignature == null)
            {
                return result;
            }

            return null;
        }

        /// <summary>
        /// Tests to see if a given list of settings matches a set of filters exactly.
        /// </summary>
        /// <param name="settings">The settings to check.</param>
        /// <param name="constraints">A list of filters to check.</param>
        /// <returns>
        /// If any filter returns null, false.
        /// If there are any settings left over after all filters are processed, false.
        /// Otherwise true.
        /// </returns>
        private static bool MatchesSpecification(
            IDictionary<string, string> settings,
            params Func<IDictionary<string, string>, IDictionary<string, string>>[] constraints)
        {
            foreach (Func<IDictionary<string, string>, IDictionary<string, string>> constraint in constraints)
            {
                IDictionary<string, string> remainingSettings = constraint(settings);

                if (remainingSettings == null)
                {
                    return false;
                }
                else
                {
                    settings = remainingSettings;
                }
            }

            if (settings.Count == 0)
            {
                return true;
            }

            return false;
        }

        /// <summary>
        /// Gets a StorageCredentials object corresponding to whatever credentials are supplied in the given settings.
        /// </summary>
        /// <param name="settings">The settings to check.</param>
        /// <returns>The StorageCredentials object specified in the settings.</returns>
        private static StorageCredentials GetCredentials(IDictionary<string, string> settings)
        {
            string accountName;
            string accountKey;
            string accountKeyName;
            string sharedAccessSignature;

            settings.TryGetValue(AccountNameSettingString, out accountName);
            settings.TryGetValue(AccountKeySettingString, out accountKey);
            settings.TryGetValue(AccountKeyNameSettingString, out accountKeyName);
            settings.TryGetValue(SharedAccessSignatureSettingString, out sharedAccessSignature);

            if (accountName != null && accountKey != null && sharedAccessSignature == null)
            {
#if PORTABLE
                throw new NotSupportedException(SR.PortableDoesNotSupportSharedKey);
#else
                return new StorageCredentials(accountName, accountKey, accountKeyName);
#endif
            }

            if (accountName == null && accountKey == null && accountKeyName == null && sharedAccessSignature != null)
            {
                return new StorageCredentials(sharedAccessSignature);
            }

            return null;
        }

        /// <summary>
        /// Gets the default blob endpoint using specified settings.
        /// </summary>
        /// <param name="settings">The settings to use.</param>
        /// <returns>The default blob endpoint.</returns>
        private static StorageUri ConstructBlobEndpoint(IDictionary<string, string> settings)
        {
            return ConstructBlobEndpoint(
                settings[DefaultEndpointsProtocolSettingString],
                settings[AccountNameSettingString],
                settings.ContainsKey(EndpointSuffixSettingString) ? settings[EndpointSuffixSettingString] : null);
        }

        /// <summary>
        /// Gets the default blob endpoint using the specified protocol and account name.
        /// </summary>
        /// <param name="scheme">The protocol to use.</param>
        /// <param name="accountName">The name of the storage account.</param>
        /// <param name="endpointSuffix">The Endpoint DNS suffix; use <c>null</c> for default.</param>
        /// <returns>The default blob endpoint.</returns>
        private static StorageUri ConstructBlobEndpoint(string scheme, string accountName, string endpointSuffix)
        {
            if (string.IsNullOrEmpty(scheme))
            {
                throw new ArgumentNullException("scheme");
            }

            if (string.IsNullOrEmpty(accountName))
            {
                throw new ArgumentNullException("accountName");
            }

            if (string.IsNullOrEmpty(endpointSuffix))
            {
                endpointSuffix = DefaultEndpointSuffix;
            }

            string primaryUri = string.Format(
                CultureInfo.InvariantCulture,
                "{0}://{1}.{2}.{3}/",
                scheme,
                accountName,
                DefaultBlobHostnamePrefix,
                endpointSuffix);

            string secondaryUri = string.Format(
                CultureInfo.InvariantCulture,
                "{0}://{1}{2}.{3}.{4}",
                scheme,
                accountName,
                SecondaryLocationAccountSuffix,
                DefaultBlobHostnamePrefix,
                endpointSuffix);

            return new StorageUri(new Uri(primaryUri), new Uri(secondaryUri));
        }

        /// <summary>
        /// Gets the default file endpoint using specified settings.
        /// </summary>
        /// <param name="settings">The settings to use.</param>
        /// <returns>The default file endpoint.</returns>
        private static StorageUri ConstructFileEndpoint(IDictionary<string, string> settings)
        {
            return ConstructFileEndpoint(
                settings[DefaultEndpointsProtocolSettingString],
                settings[AccountNameSettingString],
                settings.ContainsKey(EndpointSuffixSettingString) ? settings[EndpointSuffixSettingString] : null);
        }

        /// <summary>
        /// Gets the default file endpoint using the specified protocol and account name.
        /// </summary>
        /// <param name="scheme">The protocol to use.</param>
        /// <param name="accountName">The name of the storage account.</param>
        /// <param name="endpointSuffix">The Endpoint DNS suffix; use <c>null</c> for default.</param>
        /// <returns>The default file endpoint.</returns>
        private static StorageUri ConstructFileEndpoint(string scheme, string accountName, string endpointSuffix)
        {
            if (string.IsNullOrEmpty(scheme))
            {
                throw new ArgumentNullException("scheme");
            }

            if (string.IsNullOrEmpty(accountName))
            {
                throw new ArgumentNullException("accountName");
            }

            if (string.IsNullOrEmpty(endpointSuffix))
            {
                endpointSuffix = DefaultEndpointSuffix;
            }

            string primaryUri = string.Format(
                CultureInfo.InvariantCulture,
                "{0}://{1}.{2}.{3}/",
                scheme,
                accountName,
                DefaultFileHostnamePrefix,
                endpointSuffix);

            string secondaryUri = string.Format(
                CultureInfo.InvariantCulture,
                "{0}://{1}{2}.{3}.{4}",
                scheme,
                accountName,
                SecondaryLocationAccountSuffix,
                DefaultFileHostnamePrefix,
                endpointSuffix);

            return new StorageUri(new Uri(primaryUri), new Uri(secondaryUri));
        }

        /// <summary>
        /// Gets the default queue endpoint using the specified settings.
        /// </summary>
        /// <param name="settings">The settings.</param>
        /// <returns>The default queue endpoint.</returns>
        private static StorageUri ConstructQueueEndpoint(IDictionary<string, string> settings)
        {
            return ConstructQueueEndpoint(
                settings[DefaultEndpointsProtocolSettingString],
                settings[AccountNameSettingString],
                settings.ContainsKey(EndpointSuffixSettingString) ? settings[EndpointSuffixSettingString] : null);
        }

        /// <summary>
        /// Gets the default queue endpoint using the specified protocol and account name.
        /// </summary>
        /// <param name="scheme">The protocol to use.</param>
        /// <param name="accountName">The name of the storage account.</param>
        /// <param name="endpointSuffix">The Endpoint DNS suffix; use <c>null</c> for default.</param>
        /// <returns>The default queue endpoint.</returns>
        private static StorageUri ConstructQueueEndpoint(string scheme, string accountName, string endpointSuffix)
        {
            if (string.IsNullOrEmpty(scheme))
            {
                throw new ArgumentNullException("scheme");
            }

            if (string.IsNullOrEmpty(accountName))
            {
                throw new ArgumentNullException("accountName");
            }

            if (string.IsNullOrEmpty(endpointSuffix))
            {
                endpointSuffix = DefaultEndpointSuffix;
            }

            string primaryUri = string.Format(
                CultureInfo.InvariantCulture,
                "{0}://{1}.{2}.{3}/",
                scheme,
                accountName,
                DefaultQueueHostnamePrefix,
                endpointSuffix);

            string secondaryUri = string.Format(
                CultureInfo.InvariantCulture,
                "{0}://{1}{2}.{3}.{4}",
                scheme,
                accountName,
                SecondaryLocationAccountSuffix,
                DefaultQueueHostnamePrefix,
                endpointSuffix);

            return new StorageUri(new Uri(primaryUri), new Uri(secondaryUri));
        }

        /// <summary>
        /// Gets the default table endpoint using the specified settings.
        /// </summary>
        /// <param name="settings">The settings.</param>
        /// <returns>The default table endpoint.</returns>
        private static StorageUri ConstructTableEndpoint(IDictionary<string, string> settings)
        {
            return ConstructTableEndpoint(
                settings[DefaultEndpointsProtocolSettingString],
                settings[AccountNameSettingString],
                settings.ContainsKey(EndpointSuffixSettingString) ? settings[EndpointSuffixSettingString] : null);
        }

        /// <summary>
        /// Gets the default table endpoint using the specified protocol and account name.
        /// </summary>
        /// <param name="scheme">The protocol to use.</param>
        /// <param name="accountName">The name of the storage account.</param>
        /// <param name="endpointSuffix">The Endpoint DNS suffix; use <c>null</c> for default.</param>
        /// <returns>The default table endpoint.</returns>
        private static StorageUri ConstructTableEndpoint(string scheme, string accountName, string endpointSuffix)
        {
            if (string.IsNullOrEmpty(scheme))
            {
                throw new ArgumentNullException("scheme");
            }

            if (string.IsNullOrEmpty(accountName))
            {
                throw new ArgumentNullException("accountName");
            }

            if (string.IsNullOrEmpty(endpointSuffix))
            {
                endpointSuffix = DefaultEndpointSuffix;
            }

            string primaryUri = string.Format(
                CultureInfo.InvariantCulture,
                "{0}://{1}.{2}.{3}/",
                scheme,
                accountName,
                DefaultTableHostnamePrefix,
                endpointSuffix);

            string secondaryUri = string.Format(
                CultureInfo.InvariantCulture,
                "{0}://{1}{2}.{3}.{4}",
                scheme,
                accountName,
                SecondaryLocationAccountSuffix,
                DefaultTableHostnamePrefix,
                endpointSuffix);

            return new StorageUri(new Uri(primaryUri), new Uri(secondaryUri));
        }
    }
}

redpajama_set_name: RedPajamaGithub


text: Q: Scikit-Learn like models for production? I've currently fit a model using sktime (a scikit like library) which provides interfaces to dump and load pickled models. However if I fit in x86 (64 bit OS) and run inference on raspberry pi zero which is armv6 (32 bit OS) the predictions are completely different on the same test set. Digging deeper into the issue I found we have to export in either PMML or ONNX format and then inference using that for cross-architecture operations. The problem is PMML is limited and doesn't support sktime functions and ONNX Runtime Inference is currently broken for raspberry pi zero w (armv6). What are my options?

redpajama_set_name: RedPajamaStackExchange