text:
Foreign Office updates travel advice for USA, Spain, France, Dubai and more
Fully vaccinated UK travellers will be able to visit the US from November 8.
This will end the blanket ban on foreign travellers from entering the country introduced by then-president Donald Trump in March 2020 due to coronavirus.
The new policy was announced last month, but it was not previously known when in November it would be implemented.
READ MORE: Grieving family of mum who died of cancer refused refund for cancelled holiday
The lifting of the travel ban is a major boost for the UK's struggling airlines, airports and travel firms.
British Airways chief executive Sean Doyle said: "Nearly 600 days since the introduction of the US travel ban, this is a pivotal moment for the entire travel industry and finally provides the certainty we have so desperately needed.
"We can't wait to welcome our customers back on board and reconnect friends and families across the Atlantic, rebuild US-UK business relationships and reclaim Britain's position as a leader on the global stage."
Here's the latest advice from the Foreign Office for travel advice for USA, Spain, France, Dubai and more
Foreign visitors arriving in the US by air will be required to show proof of vaccination before boarding a flight, and evidence of a recent negative Covid-19 test.
Vaccinations administered in the UK will be accepted by the US.
Travellers who are not fully vaccinated will continue to be prohibited from entering the country.
The Spanish government requires all arrivals to Spain from the UK to present on entry a pre-travel declaration form and one of the following: a negative COVID-19 test; or proof of vaccination.
Spain will accept the UK's COVID-19 vaccination record.
Your NHS appointment card from vaccination centres is not designed to be used as proof of vaccination and should not be used to demonstrate your vaccine status.
The UK is currently on the French amber list. Entry requirements are different depending on whether you are fully vaccinated or not.
Unvaccinated (or not fully vaccinated) arrivals in France from countries on the French amber list will only be permitted to travel for essential reasons (from the list specified for this category of country). If you are not fully vaccinated, you will need to have an essential reason to travel from France to a country on France's amber list.
Those who are not fully vaccinated will also need to present the following documents:
a completed International Travel Certificate to confirm their essential reason for travel. In exceptional circumstances, the French Consulate in London may be able to assist with travel for an essential reason not listed on the International Travel Certificate
a completed 'sworn statement' (déclaration sur l'honneur) form self-certifying they are not suffering from symptoms associated with coronavirus and have not been in contact with confirmed cases in the preceding fortnight, and that they will self-isolate for seven days after arrival. This can be found on the French government's website.
From Sunday July 18, arrivals from the UK aged 12 years old or over are required to present evidence of a negative test (PCR or antigen) taken within 24 hours of departure (first flight departure in case of connecting flight). Self-administered tests are not accepted. Arrivals from most other amber countries will need evidence of a negative PCR test taken within 72 hours of departure or an antigen test taken within 48 hours of departure.
Travellers who are not fully vaccinated will need to self-isolate for seven days after arrival, then take another PCR test following this period of self-isolation.
Children aged 12 years old or over who are not fully vaccinated and travelling with a fully vaccinated adult are required to present a negative test result (PCR or antigen). However, they do not need to provide an essential reason for travel, nor do they need to self-isolate on arrival.
Children aged 12 years old or over who are unvaccinated and travelling alone are subject to the same conditions adults who are not fully vaccinated. Children aged 11 years old or younger do not need to present a negative test result to travel.
Travellers who are fully vaccinated do not need an essential reason to travel to France and do not need to self-isolate on arrival. From July 18, fully vaccinated travellers no longer need to present evidence of a negative test result before travel. Fully vaccinated travellers will need to present the following documents:
a completed 'sworn statement' (déclaration sur l'honneur) form self-certifying they are not suffering from symptoms associated with coronavirus and have not been in contact with confirmed cases in the preceding fortnight. This can be found on the French government's website
proof of vaccination status
United Arab Emirates (Dubai):
Residents, tourists and visitors travelling from or through the UK and arriving in Dubai and Abu Dhabi must have a negative COVID-19 PCR test before departure and present the certificate at check in.
These need to be taken no more than 72 hours prior to departure for arrivals to Dubai and no more than 48 hours prior to departure for arrivals to Abu Dhabi.
Travellers arriving in Abu Dhabi will also be required to undertake a COVID-19 PCR test on arrival.
Travellers arriving in Dubai may be required to undertake a further COVID-19 PCR test on arrival and will have to isolate pending the result of the COVID-19 PCR test.
If you travel from the UK and can demonstrate that you are fully vaccinated, you can enter Italy without needing to self-isolate if you also:
fill in the passenger locator form (EU PLF) before you enter Italy to get a QR code to show to your travel provider and Border Police. You can ask for paper form if you do not have an electronic device
show evidence of a negative PCR or antigen test, taken within 48 hours before entering Italy
If you are not vaccinated, to enter Italy from the UK you must:
fill in the passenger locator form (EU PLF) to get a QR code to show to your travel provider and Border Police. You can ask for paper form if you do not have an electronic device
notify the Prevention Department of the local health authority of your entry into Italy. See COVID-19 Numeri verdi regionali for the contact details of local Italian health authorities
travel to your final destination in Italy by private transport only
remain in self-isolation for five days
take another PCR or antigen test at the end of the five days' self-isolation
Receive newsletters with the latest news, sport and what's on updates from the Liverpool ECHO by signing up here.
Tags: Advice Dubai Foreign France Office Spain Travel updates USA
Previous Canada Finally Ends Advisory Against Non-Essential Travel Begun In March 2020
Next CDC raises Covid travel advisory level for Singapore, Hong Kong

redpajama_set_name: RedPajamaCommonCrawl


The domain of a rational function is all real numbers that make the denominator nonzero, which is fairly easy to find; however, the range of a rational function is not as easy to find as the domain. You will have to know the graph of the function to find its range.
Since the middle piece spans from #-infty# to #+infty#, the range is #(-infty,infty)#.


text:
IGNITE UCC Clár Gnó Iarchéime IGNITE
Programme Partner
Bank of Ireland is Ireland's largest bank offering a full range of banking service for individuals, businesses and corporates.
Bank of Ireland has supported IGNITE since 2012 as part of a remit to support start-ups and SMEs across the country. As well as valuable financial support, the bank provides IGNITE participants with access to practical financial advice, an extensive network of contacts and to the Bank of Ireland Innovation Team.
Musgrave Group
Musgrave is Ireland's leading food retail and wholesale company. Musgrave's brands, including SuperValu, Centra and Daybreak, are market leaders and Musgrave MarketPlace is Ireland's leading wholesale supplier to retail, foodservice and SMEs.
Musgrave Group has supported the programme since 2016 providing valuable financial support as well as access to Musgrave's food sector knowhow and a valuable industry network.
Cork County Council is the local authority responsible for local government in County Cork, the largest county in Ireland with an area of 7,500 sq km and a population of over 400,000.
The Council has supported the programme since 2011 as part of its remit to support economic development in the region. The Council provides financial support through its Economic Development Fund as well as practical non-financial supports as appropriate.
Cork City Council is the local authority responsible for local government in Cork City, the second largest city in Ireland with a population of over 125,000.
Local Enterprise Offices
The Local Enterprise Offices form a network of 31 offices across the country that provide training, mentoring and financial supports to anyone starting or growing a business.
The three Local Enterprise Offices (LEO) of Cork City, South Cork and North & West Cork have supported IGNITE since its launch in 2011. The LEOs provide important financial support to the programme.
Showcase & Awards Partner
KPMG is a professional service company and one of the Big Four auditors in Ireland with 86 partners and over 2800 people based in Dublin, Belfast, Cork and Galway.
KPMG has supported IGNITE since 2018 providing financial support for the IGNITE Showcase & Awards Events and providing valuable access to company formation, taxation and business advice.
Ronan Daly Jermyn
Ronan Daly Jermyn (RDJ) is a top 10 Irish law firm headquartered in Cork. The firm employs over 240 people in Cork, Dublin, Galway and London.
RDJ has supported IGNITE since 2018 providing financial support for the IGNITE Showcase & Awards Events and providing valuable access to advice on company structures, funding, taxation, data protection and employment law.
IGNITE UCC
Clár Gnó Iarchéime IGNITE
Western Gateway Building, University College Cork
ignite@ucc.ie


text:
Amsterdam Impact
Impact ecosystem insights
Insights and features
Amsterdam's social enterprises on the rise
Social enterprises in the Netherlands form a growing segment of the economy, and Amsterdam is at the forefront.
Amsterdam inspires
According to the annual study of the most inspiring organisations in the Netherlands, social enterprises are now outperforming traditional companies. The most recent version of this annual "Inspirational 40" study was published (Dutch link) in November by consulting firm Synergie (Dutch link).
The top score in the survey, for example, went to the Amsterdam-based chocolate company Tony's Chocolonely, which focuses on ensuring that cocoa farmers are not exploited. Tony's now accounts for 12% of all the chocolate bars sold in the Netherlands. Another social enterprise in the top three is Dopper, a maker of reusable water bottles that was founded in Haarlem in 2010 with the goal of reducing the amount of pollution in our oceans.
Amsterdam social enterprises on the rise
Although there are varying interpretations of what a social enterprise is, it is generally defined as a company for which social impact is more important than the money earned for shareholders. Popular social enterprises based in the Amsterdam region include the energy supplier Van de Bron (which is also on Synergie's top-40 list), Koeckebackers, Marqt and Almere-based MUD Jeans.
In its recent survey of 182 social enterprises in the Netherlands, the consultancy firm McKinsey found that social enterprises are playing a larger role than ever in the Dutch economy, having added 25,000 new jobs to the economy since 2010, accounting for sales of roughly € 3.5 billion.
Amsterdam makes social entrepreneurship easier
Amsterdam is at the forefront of the social-enterprise movement and contributes to building the social entrepreneurship ecosystem by bringing together a network of entrepreneurs, investors, corporates, universities and more. Recent activities include the Buy Social B2B event – which matched social enterprises with potential customers – and Capital Impact, an event held in September which aimed to solidify Amsterdam's role as the global hub for social enterprises. The city's Social Enterprise Action Plan 2015-2018 (PDF, in Dutch) has more details on the measures that Amsterdam is taking to create the optimal environment for social entrepreneurship.
Amsterdam's local social enterprises pave the way for a greener future
Ranking in the top five of the most bicycle-friendly, sustainable and innovative cities in the world in 2015, Amsterdam has secured its position as a ...
Amsterdam's social enterprises win awards
In the past few months, more and more social entrepreneurs based in Amsterdam have been winning prizes for their innovative products.
5 Amsterdam innovators leading the way in sustainable fashion
The Amsterdam Area's fashion industry might not be known for its couture, but it is definitely thriving as a home to major labels and innova...
A new accelerator for social entrepreneurs launching in Amsterdam
The course has been designed to help entrepreneurs focused on doing social good to be seen, heard and supported as they work to improve society and th...
Amsterdam delves into social entrepreneurship with Capital Impact
Amsterdam is famous for its entrepreneurial spirit, and it is already well-known as a startup city. Now, the Dutch capital wants to become known as a ...
Plug and Play's Fashion for Good accelerator launches third edition
The latest round of Fashion for Good's Plug and Play accelerator programme kicked off on 19 March at the Fashion for Good hub in Amsterdam.
What happens at our Buy Social events
On 17 October 2017, in partnership with Social Enterprise NL and ABN Amro, Amsterdam Impact ran another successful Buy Social event, held at the Circl...
Let's connect for impact in 2017
Join the City of Amsterdam in its mission to promote social enterprises. Find out how you can be a part of this important and expanding sector in 2017...
Connect to Amsterdam's impact-driven economy
Amsterdam is building a region where citizen well-being and economic growth go hand in hand. Find out how you can join forces with the companies, impa...
A code for the Netherlands' social enterprises
A consultation version of a Social Enterprises Code has been drafted, so it's time for entrepreneurs and other stakeholders in the Netherlands to deli...
The proof is in the deal flow
The social entrepreneurial ecosystem in Amsterdam is growing. With concrete deals being brokered between impact investors and entrepreneurs, this emer...
Doing good for people and the planet
Social enterprises thrive in Amsterdam, due to the city's history of entrepreneurship, its commitment to solving societal problems, and flourishing lo...
City programmes and priorities
Below, find a link to more information about the City of Amsterdam's public programmes, plans, policies and government schemes across a range of socia...
Third #BuySocialNL event for Amsterdam Metropolitan Area
On 30 March, in partnership with Social Enterprise NL, the Amsterdam Metropolitan Area ran the third Buy Social event, held at Schiphol Group. Various...
Tony's Chocolonely named most sustainable Dutch brand for third time
The ethical chocolate company topped the Netherlands' Sustainable Brand Index for the third time.


My living room and I mean 'living'! It's my bedroom, lounge room and office. It's mine and only mine.
Creative services director in an advertising agency.
Sleeping, thinking, journaling, singing, reading, meditating, talking, nurturing, eating and observing life through the lens of the internet.
My butterflies, Derek and Darrell.
A vintage oriental wall divider and more taxidermy.
When I walk into this room I feel loved, at peace, chuffed and attracted to its beauty. It's everything I visualised years ago, but never had the opportunity to make happen.
When friends visit they always sit in the teal velvet chair and for some reason that makes me happy.
06 Apr	This entry was published on April 6, 2017 at 7:50 am. It's filed under Uncategorized and tagged Antique mannequin, Apartment, Apartment living, bedroom, Butterflies, Chandelier, Deer head, Floral wallpaper, Florence Broadhurst, Iconography, Living room, Melbourne, Oriental style, Peacock feathers, taxidermy, Vintage, Vintage art.	Bookmark the permalink.	Follow any comments here with the RSS feed for this post.
Wow! This room is oozing with personal style. I love the furniture pieces and decorations, so glamorous.


text:
Home / Partners / Keith R. Fowke
Keith R. Fowke
Keith Fowke, BSc(H), PhD, Head, Medical Microbiology & Infectious Diseases, University of Manitoba
Dr. Fowke is currently cross appointed as a Professor in the U of M's Department of Community Health Sciences and is a Visiting Lecturer in the Department of Medical Microbiology at the University of Nairobi. Dr. Fowke has established a vital, active research laboratory consisting of a technician, graduate students, postdoctoral and clinical fellows, research fellows, BSc (Med) and summer research students. The Viral Immunology Laboratory is currently focusing on three major areas of research: i) determining the immunological phenotype and genetic expression of CD4+ T-cells in individuals who are resistant to HIV infection or those who are infected but able to control their viral replication; ii) the role of immune activation and receptor polymorphisms in HIV disease progression; and, iii) defining the role of pre-existing humoral and cellular immunity to influenza (including H1N1) and disease outcomes as well as immune responses to vaccine and exposure. Dr. Fowke's research has been recognized with the Ken Hughes Young Investigator award in 2005, a Canadian Institutes for Health Research (CIHR) New Investigator Award (2005-2010) and a Manitoba Research Chair from the Manitoba Health Research Council (2008-2013). Dr. Fowke has a particular interest in training young investigators and, in addition to supervising a number of graduate student and post-doctoral fellows, has helped organize a number of national and international workshops for young investigators and is principal investigator for the CIHR International Infectious Disease and Global Health Training Program. (From mrsi.med.umanitoba.ca)


So right here we go, the very best 10 movies about 'magic' of 'all time'. Quality of the video varies however you'll be able to see on cover what video quality have the film: HD, DVD, CAM, 3D. About 3D movies, I wasn't able to check does the movies are actually in 3D, but you probably have 3D monitor you can test this selection.
– On-line streaming (steady stream of data) is a stream of video or music on the web without the necessity so that you can obtain a file, so we must say that our website is the easiest way to do this since you save time and area on downloading and so finally yow will discover and watch your greatest websites for on-line streaming movies with out downloading anything.
Bellow we've prepared a desk of on-line movie streaming sites all of them have been carefully reviewed and categorized so you'll be able to select the one that matches you probably the most but first be sure you bookmark us so we are able to maintain you updated about new data on daily basis because you wont be dissapointed.
For me always is great when is big amount of choice available, it often means that there will probably be some web site most ample for me. However when there are numerous web sites also lots of them are dangerous and you'll lost all of your time in annoying and in hopeless browsing to search out cartoons you wish to watch and even for those who discover, they have poor quality and finally you will lost all of your desire to observe.
On the subject of movie nights we're one of the best as a result of we give our reader the quickest response possible, the best layout and an excessive amount of NEW sites to look at tv and movies on-line as well as our support for any inconveniences that you just may get into.
Most of these streaming sites are good for more reasons: They have streams with different video quality, enough streams for all web speeds and for all platforms and there are all the time some streams even for some movies that are not widespread.
I then needed to watch every little thing Buster ever made, then moved on to Chaplin, then on to films from the early sound era….and when I discovered the superb neighborhood of basic movie lovers on Twitter and within the blogosphere, I decided I actually needed to make watching and writing about classic movie a serious hobby.


After starting the season 3-2, including a blowout loss to Air Force, Boise State has responded to head coach Bryan Harsin's calls for improvement by winning seven straight games to end the regular season. The Broncos possess a very good offense that is averaging 40.8 points per game on 513 total yards at 6.5 yards per play and 12.6 yards per point against teams that would combine to allow just 5.5 yards per play to a mediocre offensive squad.
More importantly, the Broncos are 6-0 SU and 4-2 ATS at home this season where they are averaging 41.8 points per game on 533 total yards at 6.6 yards per play and 12.8 yards per point. Overall, Boise State is 0.7 yards per rush play, 1.5 yards per pass play and 1.0 yards per play better than average offensively in 2014, which is good enough to exploit a subpar Fresno State stop unit.
Indeed, Fresno State is allowing 33.0 points per game on 468 total yards at 6.2 yards per play to teams that would combine to average just 5.7 yards per play to a mediocre offensive squad. Even more alarming is the fact that the Bulldogs are 2-4 on the road where they are yielding 37.0 points per game on 489 total yards at 6.1 yards per play. Overall, Fresno State is 0.1 yards per rush play, 1.3 yards per pass play and 0.5 yards per play worse than average defensively this season.
Boise State quarterback Grant Hedrick, who averaged 9.0 yards per pass completion in the Broncos first meeting with Fresno State, should easily eclipse that output in light of the fact that he is averaging 12.4 yards per pass completion in 2014. In fact, Boise State possesses a significant +2.8 yards per pass attempt advantage over Fresno State's woeful secondary. Look for the Broncos to move the chains at will through the air in the Mountain West Conference championship game.
What many amateur sports bettors do not realize is the fact that Fresno State's offense is 0.5 yards per play worse than average (5.4 yards per play against teams that would combine to allow 5.9 yards per play). Even worse is the Bulldogs' passing game, which is averaging a pathetic 6.1 yards per play against a group of secondaries that would combine to allow 7.1 yards per pass attempt. Meanwhile, Boise State takes the field with a very good defense that is 0.4 yards per play better than average (5.4 yards per play to teams that would combine to average 5.8 yards per play).
Based purely from the line of scrimmage, Boise State possesses a 1.5 yards per play advantage offensively and a 0.9 yards per play advantage defensively. From a technical standpoint, Boise State is 58-38 ATS at home, 56-35 ATS off a double-digit win over a Mountain West Conference opponent, 38-18 ATS after six or more consecutive wins and 70-40 ATS in the second half of the season. Finally, the Broncos are 12-2 ATS in this series, while Fresno State is 1-6 in its last seven trips to the Blue Turf.


I am happy to be back sharing a twist on one of my favorite patterns today – the curvy zipper pouch. Today I will be showing how to turn one pouch into a trio set.
I love this pouch, especially in the smaller size. Isn't the mini adorable? Add the nature themed fabric from DailyLike Canada and the pouches are perfection.
Metal zippers can be difficult to work with. I suggest lengthening the stitch length and then slowly sewing over the zipper. You can always use a regular zipper.
This pouch has a tab at one end. I love this feature, as it makes for a really wide pouch opening.
On my blog, HaberdasheryFun, I share a unique approach to sewing the top curve. It is also ok to attach the zipper the regular "old fashioned" way.
For an extra study pouch, use interfacing on both the exterior and interior fabrics.
If re-sizing the pouch as per this post, use a 1/4″ – 3/8″ seam allowance.
Print the original Curvy Zipper Pattern.
Place the pattern into the photocopier and use the ratio options to resize the pattern. Always start from the original pattern. Resize to 75% and print, resize to 65% and print and lastly, resize to 50% and print. It's that simple..!
These smaller pattern pieces fit on a letter size piece of paper. To get a full pattern you can 1) Fold along the CF line, staple together and then cut the pattern out. 2) Print 2 copies and tape along the CF line.
Cut your pattern pieces – 2 outside, 2 lining and 1 zipper tab.
Measure and trim zipper down to size. Quick tip – add 1/8″ – 1/4″ to each top side seam allowance. Trim the zipper down to this new measurement. This extra wiggle room helps turn a great zipper corner.
Trim zipper to size [at one end]. Turn and fold zipper tab. Insert tab over raw zipper end and sew.
Sew the zipper along the top edge of front pouch. Repeat for back side. Note that you can use either method for attaching zipper. My original blog post gives a fun approach, but the regular old fashioned way works just as great.
Sew the zipper to the lining front. Repeat for the back side.
Open zipper. Place outside pieces, right sides facing. Pin. Place lining pieces, right sides facing. Pin. Sew together with a smaller seam allowance. Remember to leave a small opening at the lining bottom edge.
Sew all 4 boxed corners.
Turn right side out. Pin lining bottom edge together and sew.
That's it! Hope you like this fun idea for making a trio set. You can buy the pattern in my online store. I will be sharing more patterns soon.


Henri de Toulouse-Lautrec's posters for the Montmartre entertainment scene have outlived the notoriety of the performers they once promoted. But during the 1890s these images functioned as part of a multifaceted system of commercial representation through which figures like Jane Avril, Aristide Bruant, Loïe Fuller, and Yvette Guilbert wooed their respective publics.
In this lecture, Howard Lay, associate professor in the Department of the History of Art at the University of Michigan, offers a nuanced analysis of Toulouse-Lautrec's posters, many of which are included in the current exhibition Spectacle and Leisure in Paris: Degas to Mucha, to provide additional context on the proliferation of promotional imagery in late 19th-century Paris. To reacquaint these posters with their own historical moment is to see them, at least provisionally, through the eyes of the fin-de-siècle Parisians to whom their messages were originally directed.
Henri de Toulouse-Lautrec (French, 1864–1901), Jane Avril, 1893. Color lithograph, 51 3/16 x 37". Gift of John F. Lesser in memory of Jenny Nathan Strauss, 2000.


Candy bars don't stand a chance against this seriously delectable 10-gram bar. Caramel and pecans join forces to be surrounded by chocolate and consumed by you.
Soy Protein Isolate, Sugar, Maltitol Syrup, Corn Syrup, Calcium Caseinate (From Milk), Polydextrose, Partially Hydrogenated Vegetable Oil (Palm Kernel, Palm, Soybean, Cottonseed) (Contributes a Negligible Amount of Trans Fat), Molasses, Whey Protein Isolate, Sweetened Condensed Milk (Milk, Sugar), Evaporated Milk (Milk, Potassium Phosphate, Carrageenan, Vitamin D3), Cocoa, Water, Pecans, Invert Sugar, Soy Lecithin, Cellulose Gum, Natural and Artificial Flavors, Milk, Rice Flour, Cream, Mono and Diglycerides, Salt, Barley Malt Extract, Peanut Oil, Sorbitan Monostearate, Polysorbate 60, Guar Gum, Sodium Phosphate.
CONTAINS PECANS. MAY CONTAIN TRACES OF PEANUTS AND OTHER NUTS.


text:
Q: How to order, grouped linq query by getting summation of element in each group c# I have an entity i would say it as "Items",
Structure of this entity like below,
string itemName
int groupId
decimal itemPrice
int itemQty

first i wanted to group it by groupId and return it as a list of list of items (List<List<Items>>)
I followed this instruction and successfully did it. Using Linq to group a list of objects into a new grouped list of list of objects
Here is my code to get that List<List<Item>>
var groupedItem = rawItemData
        .GroupBy(u => u.groupId)
        .Select(grp => grp.ToList())
        .ToList();

But now i want to order each group(list) by getting summation of itemPrice on it.
Example for my expectation:

*

*1st element of my result has 5 Items, Summation of item price in this group is 350

*2nd element of my result has 10 Items, Summation of item price in this group is 500

*3rd element of my result has 2 Items, Summation of item price in this group is 150

*4th element of my result has 6 Items, Summation of item price in this group is 555

I want to group my main result by this summation of item price,
Expected order is like below,
4th element, 2nd element, 1st element, 3rd element.
Something very hard to explain, Please let me know if need more clarification on this question.
Thank you very much!

redpajama_set_name: RedPajamaStackExchange


Ha! Day one in Nashville consisted of breakfast at the Farmer's Market, a walk through Bicentennial Park and a full day at the pool.
Bicentennial Park has a really cool map of Tennessee on the ground. Andy and I discovered a must-see city that I'll have to stop in on my way out of town. Mitchellville or bust.
Capped off the night at Rebar, Red Door and Blue Bar.


text:
package org.apache.beam.sdk.io;

import static com.google.common.base.MoreObjects.firstNonNull;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;

import com.google.common.annotations.VisibleForTesting;
import com.google.protobuf.ByteString;

import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.Channels;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.SeekableByteChannel;
import java.nio.channels.WritableByteChannel;
import java.nio.charset.StandardCharsets;
import java.util.NoSuchElementException;
import java.util.regex.Pattern;

import javax.annotation.Nullable;

import org.apache.beam.sdk.coders.Coder;
import org.apache.beam.sdk.coders.Coder.Context;
import org.apache.beam.sdk.coders.StringUtf8Coder;
import org.apache.beam.sdk.coders.VoidCoder;
import org.apache.beam.sdk.io.FileBasedSink.WritableByteChannelFactory;
import org.apache.beam.sdk.io.Read.Bounded;
import org.apache.beam.sdk.options.PipelineOptions;
import org.apache.beam.sdk.options.ValueProvider;
import org.apache.beam.sdk.options.ValueProvider.StaticValueProvider;
import org.apache.beam.sdk.transforms.PTransform;
import org.apache.beam.sdk.transforms.display.DisplayData;
import org.apache.beam.sdk.util.IOChannelUtils;
import org.apache.beam.sdk.util.MimeTypes;
import org.apache.beam.sdk.values.PBegin;
import org.apache.beam.sdk.values.PCollection;
import org.apache.beam.sdk.values.PDone;

/**
 * {@link PTransform}s for reading and writing text files.
 *
 *
To read a {@link PCollection} from one or more text files, use {@link TextIO.Read}.
 * You can instantiate a transform using {@link TextIO.Read#from(String)} to specify
 * the path of the file(s) to read from (e.g., a local filename or
 * filename pattern if running locally, or a Google Cloud Storage
 * filename or filename pattern of the form
 * {@code "gs://<bucket>/<filepath>"}).
 *
 *
By default, {@link TextIO.Read} returns a {@link PCollection} of {@link String Strings},
 * each corresponding to one line of an input UTF-8 text file. To convert directly from the raw
 * bytes (split into lines delimited by '\n', '\r', or '\r\n') to another object of type {@code T},
 * supply a {@code Coder<T>} using {@link TextIO.Read#withCoder(Coder)}.
 *
 *
See the following examples:
 *
 *
{@code
 * Pipeline p = ...;
 *
 * // A simple Read of a local file (only runs locally):
 * PCollection<String> lines =
 *     p.apply(TextIO.Read.from("/local/path/to/file.txt"));
 *
 * // A fully-specified Read from a GCS file:
 * PCollection<Integer> numbers =
 *     p.apply("ReadNumbers", TextIO.Read
 *         .from("gs://my_bucket/path/to/numbers-*.txt")
 *         .withCoder(TextualIntegerCoder.of()));
 * }

 *
 *
To write a {@link PCollection} to one or more text files, use
 * {@link TextIO.Write}, specifying {@link TextIO.Write#to(String)} to specify
 * the path of the file to write to (e.g., a local filename or sharded
 * filename pattern if running locally, or a Google Cloud Storage
 * filename or sharded filename pattern of the form
 * {@code "gs://<bucket>/<filepath>"}). You can use {@link TextIO.Write#withCoder(Coder)}
 * to specify the {@link Coder} to use to encode the Java values into text lines.
 *
 *
Any existing files with the same names as generated output files
 * will be overwritten.
 *
 *
For example:
 *
{@code
 * // A simple Write to a local file (only runs locally):
 * PCollection<String> lines = ...;
 * lines.apply(TextIO.Write.to("/path/to/file.txt"));
 *
 * // A fully-specified Write to a sharded GCS file:
 * PCollection<Integer> numbers = ...;
 * numbers.apply("WriteNumbers", TextIO.Write
 *      .to("gs://my_bucket/path/to/numbers")
 *      .withSuffix(".txt")
 *      .withCoder(TextualIntegerCoder.of()));
 *
 * // Same as above, only with Gzip compression:
 * PCollection<Integer> numbers = ...;
 * numbers.apply("WriteNumbers", TextIO.Write
 *      .to("gs://my_bucket/path/to/numbers")
 *      .withSuffix(".txt")
 *      .withCoder(TextualIntegerCoder.of())
 *      .withWritableByteChannelFactory(FileBasedSink.CompressionType.GZIP));
 * }

 */
public class TextIO {
  /** The default coder, which returns each line of the input file as a string. */
  public static final Coder<String> DEFAULT_TEXT_CODER = StringUtf8Coder.of();

  /**
   * A {@link PTransform} that reads from a text file (or multiple text
   * files matching a pattern) and returns a {@link PCollection} containing
   * the decoding of each of the lines of the text file(s). The
   * default decoding just returns each line as a {@link String}, but you may call
   * {@link #withCoder(Coder)} to change the return type.
   */
  public static class Read {

    /**
     * Returns a transform for reading text files that reads from the file(s)
     * with the given filename or filename pattern. This can be a local path (if running locally),
     * or a Google Cloud Storage filename or filename pattern of the form
     * {@code "gs://<bucket>/<filepath>"} (if running locally or via the Google Cloud Dataflow
     * service). Standard Java Filesystem glob patterns ("*", "?", "[..]") are supported.
     */
    public static Bound<String> from(String filepattern) {
      return new Bound<>(DEFAULT_TEXT_CODER).from(filepattern);
    }

    /**
     * Same as {@code from(filepattern)}, but accepting a {@link ValueProvider}.
     */
    public static Bound<String> from(ValueProvider<String> filepattern) {
      return new Bound<>(DEFAULT_TEXT_CODER).from(filepattern);
    }

    /**
     * Returns a transform for reading text files that uses the given
     * {@code Coder<T>} to decode each of the lines of the file into a
     * value of type {@code T}.
     *
     *
By default, uses {@link StringUtf8Coder}, which just
     * returns the text lines as Java strings.
     *
     * @param <T> the type of the decoded elements, and the elements
     * of the resulting PCollection
     */
    public static <T> Bound<T> withCoder(Coder<T> coder) {
      return new Bound<>(coder);
    }

    /**
     * Returns a transform for reading text files that has GCS path validation on
     * pipeline creation disabled.
     *
     *
This can be useful in the case where the GCS input does not
     * exist at the pipeline creation time, but is expected to be
     * available at execution time.
     */
    public static Bound<String> withoutValidation() {
      return new Bound<>(DEFAULT_TEXT_CODER).withoutValidation();
    }

    /**
     * Returns a transform for reading text files that decompresses all input files
     * using the specified compression type.
     *
     *
If no compression type is specified, the default is {@link TextIO.CompressionType#AUTO}.
     * In this mode, the compression type of the file is determined by its extension
     * (e.g., {@code *.gz} is gzipped, {@code *.bz2} is bzipped, and all other extensions are
     * uncompressed).
     */
    public static Bound<String> withCompressionType(TextIO.CompressionType compressionType) {
      return new Bound<>(DEFAULT_TEXT_CODER).withCompressionType(compressionType);
    }

    // TODO: strippingNewlines, etc.

    /**
     * A {@link PTransform} that reads from one or more text files and returns a bounded
     * {@link PCollection} containing one element for each line of the input files.
     *
     * @param <T> the type of each of the elements of the resulting
     * {@link PCollection}. By default, each line is returned as a {@link String}, however you
     * may use {@link #withCoder(Coder)} to supply a {@code Coder<T>} to produce a
     * {@code PCollection<T>} instead.
     */
    public static class Bound<T> extends PTransform<PBegin, PCollection<T>> {
      /** The filepattern to read from. */
      @Nullable private final ValueProvider<String> filepattern;

      /** The Coder to use to decode each line. */
      private final Coder<T> coder;

      /** An option to indicate if input validation is desired. Default is true. */
      private final boolean validate;

      /** Option to indicate the input source's compression type. Default is AUTO. */
      private final TextIO.CompressionType compressionType;

      Bound(Coder<T> coder) {
        this(null, null, coder, true, TextIO.CompressionType.AUTO);
      }

      private Bound(@Nullable String name, @Nullable ValueProvider<String> filepattern,
          Coder<T> coder, boolean validate, TextIO.CompressionType compressionType) {
        super(name);
        this.coder = coder;
        this.filepattern = filepattern;
        this.validate = validate;
        this.compressionType = compressionType;
      }

      /**
       * Returns a new transform for reading from text files that's like this one but
       * that reads from the file(s) with the given name or pattern. See {@link TextIO.Read#from}
       * for a description of filepatterns.
       *
       *
Does not modify this object.

       */
      public Bound<T> from(String filepattern) {
        checkNotNull(filepattern, "Filepattern cannot be empty.");
        return new Bound<>(name, StaticValueProvider.of(filepattern), coder, validate,
                           compressionType);
      }

      /**
       * Same as {@code from(filepattern)}, but accepting a {@link ValueProvider}.
       */
      public Bound<T> from(ValueProvider<String> filepattern) {
        checkNotNull(filepattern, "Filepattern cannot be empty.");
        return new Bound<>(name, filepattern, coder, validate, compressionType);
      }

      /**
       * Returns a new transform for reading from text files that's like this one but
       * that uses the given {@link Coder Coder<X>} to decode each of the
       * lines of the file into a value of type {@code X}.
       *
       *
Does not modify this object.
       *
       * @param <X> the type of the decoded elements, and the
       * elements of the resulting PCollection
       */
      public <X> Bound<X> withCoder(Coder<X> coder) {
        return new Bound<>(name, filepattern, coder, validate, compressionType);
      }

      /**
       * Returns a new transform for reading from text files that's like this one but
       * that has GCS path validation on pipeline creation disabled.
       *
       *
This can be useful in the case where the GCS input does not
       * exist at the pipeline creation time, but is expected to be
       * available at execution time.
       *
       *
Does not modify this object.
       */
      public Bound<T> withoutValidation() {
        return new Bound<>(name, filepattern, coder, false, compressionType);
      }

      /**
       * Returns a new transform for reading from text files that's like this one but
       * reads from input sources using the specified compression type.
       *
       *
If no compression type is specified, the default is {@link TextIO.CompressionType#AUTO}.
       * See {@link TextIO.Read#withCompressionType} for more details.
       *
       *
Does not modify this object.
       */
      public Bound<T> withCompressionType(TextIO.CompressionType compressionType) {
        return new Bound<>(name, filepattern, coder, validate, compressionType);
      }

      @Override
      public PCollection<T> expand(PBegin input) {
        if (filepattern == null) {
          throw new IllegalStateException("need to set the filepattern of a TextIO.Read transform");
        }

        if (validate) {
          checkState(filepattern.isAccessible(), "Cannot validate with a RVP.");
          try {
            checkState(
              !IOChannelUtils.getFactory(filepattern.get()).match(filepattern.get()).isEmpty(),
                "Unable to find any files matching %s",
                filepattern);
          } catch (IOException e) {
            throw new IllegalStateException(
              String.format("Failed to validate %s", filepattern.get()), e);
          }
        }

        final Bounded<T> read = org.apache.beam.sdk.io.Read.from(getSource());
        PCollection<T> pcol = input.getPipeline().apply("Read", read);
        // Honor the default output coder that would have been used by this PTransform.
        pcol.setCoder(getDefaultOutputCoder());
        return pcol;
      }

      // Helper to create a source specific to the requested compression type.
      protected FileBasedSource<T> getSource() {
        switch (compressionType) {
          case UNCOMPRESSED:
            return new TextSource<T>(filepattern, coder);
          case AUTO:
            return CompressedSource.from(new TextSource<T>(filepattern, coder));
          case BZIP2:
            return
                CompressedSource.from(new TextSource<T>(filepattern, coder))
                    .withDecompression(CompressedSource.CompressionMode.BZIP2);
          case GZIP:
            return
                CompressedSource.from(new TextSource<T>(filepattern, coder))
                    .withDecompression(CompressedSource.CompressionMode.GZIP);
          case ZIP:
            return
                CompressedSource.from(new TextSource<T>(filepattern, coder))
                    .withDecompression(CompressedSource.CompressionMode.ZIP);
          default:
            throw new IllegalArgumentException("Unknown compression type: " + compressionType);
        }
      }

      @Override
      public void populateDisplayData(DisplayData.Builder builder) {
        super.populateDisplayData(builder);

        String filepatternDisplay = filepattern.isAccessible()
          ? filepattern.get() : filepattern.toString();
        builder
            .add(DisplayData.item("compressionType", compressionType.toString())
              .withLabel("Compression Type"))
            .addIfNotDefault(DisplayData.item("validation", validate)
              .withLabel("Validation Enabled"), true)
            .addIfNotNull(DisplayData.item("filePattern", filepatternDisplay)
              .withLabel("File Pattern"));
      }

      @Override
      protected Coder<T> getDefaultOutputCoder() {
        return coder;
      }

      public String getFilepattern() {
        return filepattern.get();
      }

      public boolean needsValidation() {
        return validate;
      }

      public TextIO.CompressionType getCompressionType() {
        return compressionType;
      }
    }

    /** Disallow construction of utility classes. */
    private Read() {}
  }

  /////////////////////////////////////////////////////////////////////////////

  /**
   * A {@link PTransform} that writes a {@link PCollection} to text file (or
   * multiple text files matching a sharding pattern), with each
   * element of the input collection encoded into its own line.
   */
  public static class Write {

    /**
     * Returns a transform for writing to text files that writes to the file(s)
     * with the given prefix. This can be a local filename
     * (if running locally), or a Google Cloud Storage filename of
     * the form {@code "gs://<bucket>/<filepath>"}
     * (if running locally or via the Google Cloud Dataflow service).
     *
     *
The files written will begin with this prefix, followed by
     * a shard identifier (see {@link Bound#withNumShards(int)}, and end
     * in a common extension, if given by {@link Bound#withSuffix(String)}.
     */
    public static Bound<String> to(String prefix) {
      return new Bound<>(DEFAULT_TEXT_CODER).to(prefix);
    }

    /**
     * Like {@link #to(String)}, but with a {@link ValueProvider}.
     */
    public static Bound<String> to(ValueProvider<String> prefix) {
      return new Bound<>(DEFAULT_TEXT_CODER).to(prefix);
    }

    /**
     * Returns a transform for writing to text files that appends the specified suffix
     * to the created files.
     */
    public static Bound<String> withSuffix(String nameExtension) {
      return new Bound<>(DEFAULT_TEXT_CODER).withSuffix(nameExtension);
    }

    /**
     * Returns a transform for writing to text files that uses the provided shard count.
     *
     *
Constraining the number of shards is likely to reduce
     * the performance of a pipeline. Setting this value is not recommended
     * unless you require a specific number of output files.
     *
     * @param numShards the number of shards to use, or 0 to let the system
     *                  decide.
     */
    public static Bound<String> withNumShards(int numShards) {
      return new Bound<>(DEFAULT_TEXT_CODER).withNumShards(numShards);
    }

    /**
     * Returns a transform for writing to text files that uses the given shard name
     * template.
     *
     *
See {@link ShardNameTemplate} for a description of shard templates.
     */
    public static Bound<String> withShardNameTemplate(String shardTemplate) {
      return new Bound<>(DEFAULT_TEXT_CODER).withShardNameTemplate(shardTemplate);
    }

    /**
     * Returns a transform for writing to text files that forces a single file as
     * output.
     */
    public static Bound<String> withoutSharding() {
      return new Bound<>(DEFAULT_TEXT_CODER).withoutSharding();
    }

    /**
     * Returns a transform for writing to text files that uses the given
     * {@link Coder} to encode each of the elements of the input
     * {@link PCollection} into an output text line.
     *
     *
By default, uses {@link StringUtf8Coder}, which writes input
     * Java strings directly as output lines.
     *
     * @param <T> the type of the elements of the input {@link PCollection}
     */
    public static <T> Bound<T> withCoder(Coder<T> coder) {
      return new Bound<>(coder);
    }

    /**
     * Returns a transform for writing to text files that has GCS path validation on
     * pipeline creation disabled.
     *
     *
This can be useful in the case where the GCS output location does
     * not exist at the pipeline creation time, but is expected to be available
     * at execution time.
     */
    public static Bound<String> withoutValidation() {
      return new Bound<>(DEFAULT_TEXT_CODER).withoutValidation();
    }

    /**
     * Returns a transform for writing to text files that adds a header string to the files
     * it writes. Note that a newline character will be added after the header.
     *
     *
A {@code null} value will clear any previously configured header.
     *
     * @param header the string to be added as file header
     */
    public static Bound<String> withHeader(@Nullable String header) {
      return new Bound<>(DEFAULT_TEXT_CODER).withHeader(header);
    }

    /**
     * Returns a transform for writing to text files that adds a footer string to the files
     * it writes. Note that a newline character will be added after the header.
     *
     *
A {@code null} value will clear any previously configured footer.
     *
     * @param footer the string to be added as file footer
     */
    public static Bound<String> withFooter(@Nullable String footer) {
      return new Bound<>(DEFAULT_TEXT_CODER).withFooter(footer);
    }

    /**
     * Returns a transform for writing to text files like this one but that has the given
     * {@link WritableByteChannelFactory} to be used by the {@link FileBasedSink} during output. The
     * default is value is {@link FileBasedSink.CompressionType#UNCOMPRESSED}.
     *
     *
A {@code null} value will reset the value to the default value mentioned above.
     *
     * @param writableByteChannelFactory the factory to be used during output
     */
    public static Bound<String> withWritableByteChannelFactory(
        WritableByteChannelFactory writableByteChannelFactory) {
      return new Bound<>(DEFAULT_TEXT_CODER)
          .withWritableByteChannelFactory(writableByteChannelFactory);
    }

    // TODO: appendingNewlines, etc.

    /**
     * A PTransform that writes a bounded PCollection to a text file (or
     * multiple text files matching a sharding pattern), with each
     * PCollection element being encoded into its own line.
     *
     * @param <T> the type of the elements of the input PCollection
     */
    public static class Bound<T> extends PTransform<PCollection<T>, PDone> {
      private static final String DEFAULT_SHARD_TEMPLATE = ShardNameTemplate.INDEX_OF_MAX;

      /** The prefix of each file written, combined with suffix and shardTemplate. */
      private final ValueProvider<String> filenamePrefix;
      /** The suffix of each file written, combined with prefix and shardTemplate. */
      private final String filenameSuffix;

      /** An optional header to add to each file. */
      @Nullable private final String header;

      /** An optional footer to add to each file. */
      @Nullable private final String footer;

      /** The Coder to use to decode each line. */
      private final Coder<T> coder;

      /** Requested number of shards. 0 for automatic. */
      private final int numShards;

      /** The shard template of each file written, combined with prefix and suffix. */
      private final String shardTemplate;

      /** An option to indicate if output validation is desired. Default is true. */
      private final boolean validate;

      /**
       * The {@link WritableByteChannelFactory} to be used by the {@link FileBasedSink}. Default is
       * {@link FileBasedSink.CompressionType#UNCOMPRESSED}.
       */
      private final WritableByteChannelFactory writableByteChannelFactory;

      Bound(Coder<T> coder) {
        this(null, null, "", null, null, coder, 0, DEFAULT_SHARD_TEMPLATE, true,
            FileBasedSink.CompressionType.UNCOMPRESSED);
      }

      private Bound(String name, ValueProvider<String> filenamePrefix, String filenameSuffix,
          @Nullable String header, @Nullable String footer, Coder<T> coder, int numShards,
          String shardTemplate, boolean validate,
          WritableByteChannelFactory writableByteChannelFactory) {
        super(name);
        this.header = header;
        this.footer = footer;
        this.coder = coder;
        this.filenamePrefix = filenamePrefix;
        this.filenameSuffix = filenameSuffix;
        this.numShards = numShards;
        this.shardTemplate = shardTemplate;
        this.validate = validate;
        this.writableByteChannelFactory =
            firstNonNull(writableByteChannelFactory, FileBasedSink.CompressionType.UNCOMPRESSED);
      }

      /**
       * Returns a transform for writing to text files that's like this one but
       * that writes to the file(s) with the given filename prefix.
       *
       *
See {@link TextIO.Write#to(String) Write.to(String)} for more information.
       *
       *
Does not modify this object.
       */
      public Bound<T> to(String filenamePrefix) {
        validateOutputComponent(filenamePrefix);
        return new Bound<>(name, StaticValueProvider.of(filenamePrefix), filenameSuffix,
            header, footer, coder, numShards, shardTemplate, validate,
            writableByteChannelFactory);
      }

      /**
       * Like {@link #to(String)}, but with a {@link ValueProvider}.
       */
      public Bound<T> to(ValueProvider<String> filenamePrefix) {
        return new Bound<>(name, filenamePrefix, filenameSuffix, header, footer, coder, numShards,
            shardTemplate, validate, writableByteChannelFactory);
      }

      /**
       * Returns a transform for writing to text files that that's like this one but
       * that writes to the file(s) with the given filename suffix.
       *
       *
Does not modify this object.
       *
       * @see ShardNameTemplate
       */
      public Bound<T> withSuffix(String nameExtension) {
        validateOutputComponent(nameExtension);
        return new Bound<>(name, filenamePrefix, nameExtension, header, footer, coder, numShards,
            shardTemplate, validate, writableByteChannelFactory);
      }

      /**
       * Returns a transform for writing to text files that's like this one but
       * that uses the provided shard count.
       *
       *
Constraining the number of shards is likely to reduce
       * the performance of a pipeline. Setting this value is not recommended
       * unless you require a specific number of output files.
       *
       *
Does not modify this object.
       *
       * @param numShards the number of shards to use, or 0 to let the system
       *                  decide.
       * @see ShardNameTemplate
       */
      public Bound<T> withNumShards(int numShards) {
        checkArgument(numShards >= 0);
        return new Bound<>(name, filenamePrefix, filenameSuffix, header, footer, coder, numShards,
            shardTemplate, validate, writableByteChannelFactory);
      }

      /**
       * Returns a transform for writing to text files that's like this one but
       * that uses the given shard name template.
       *
       *
Does not modify this object.
       *
       * @see ShardNameTemplate
       */
      public Bound<T> withShardNameTemplate(String shardTemplate) {
        return new Bound<>(name, filenamePrefix, filenameSuffix, header, footer, coder, numShards,
            shardTemplate, validate, writableByteChannelFactory);
      }

      /**
       * Returns a transform for writing to text files that's like this one but
       * that forces a single file as output.
       *
       *
Constraining the number of shards is likely to reduce
       * the performance of a pipeline. Using this setting is not recommended
       * unless you truly require a single output file.
       *
       *
This is a shortcut for
       * {@code .withNumShards(1).withShardNameTemplate("")}
       *
       *
Does not modify this object.
       */
      public Bound<T> withoutSharding() {
        return new Bound<>(name, filenamePrefix, filenameSuffix, header, footer, coder, 1, "",
            validate, writableByteChannelFactory);
      }

      /**
       * Returns a transform for writing to text files that's like this one
       * but that uses the given {@link Coder Coder<X>} to encode each of
       * the elements of the input {@link PCollection PCollection<X>} into an
       * output text line. Does not modify this object.
       *
       * @param <X> the type of the elements of the input {@link PCollection}
       */
      public <X> Bound<X> withCoder(Coder<X> coder) {
        return new Bound<>(name, filenamePrefix, filenameSuffix, header, footer, coder, numShards,
            shardTemplate, validate, writableByteChannelFactory);
      }

      /**
       * Returns a transform for writing to text files that's like this one but
       * that has GCS output path validation on pipeline creation disabled.
       *
       *
This can be useful in the case where the GCS output location does
       * not exist at the pipeline creation time, but is expected to be
       * available at execution time.
       *
       *
Does not modify this object.
       */
      public Bound<T> withoutValidation() {
        return new Bound<>(name, filenamePrefix, filenameSuffix, header, footer, coder, numShards,
            shardTemplate, false, writableByteChannelFactory);
      }

      /**
       * Returns a transform for writing to text files that adds a header string to the files
       * it writes. Note that a newline character will be added after the header.
       *
       *
A {@code null} value will clear any previously configured header.
       *
       *
Does not modify this object.
       *
       * @param header the string to be added as file header
       */
      public Bound<T> withHeader(@Nullable String header) {
        return new Bound<>(name, filenamePrefix, filenameSuffix, header, footer, coder, numShards,
            shardTemplate, validate, writableByteChannelFactory);
      }

      /**
       * Returns a transform for writing to text files that adds a footer string to the files
       * it writes. Note that a newline character will be added after the header.
       *
       *
A {@code null} value will clear any previously configured footer.
       *
       *
Does not modify this object.
       *
       * @param footer the string to be added as file footer
       */
      public Bound<T> withFooter(@Nullable String footer) {
        return new Bound<>(name, filenamePrefix, filenameSuffix, header, footer, coder, numShards,
            shardTemplate, validate, writableByteChannelFactory);
      }

      /**
       * Returns a transform for writing to text files like this one but that has the given
       * {@link WritableByteChannelFactory} to be used by the {@link FileBasedSink} during output.
       * The default is value is {@link FileBasedSink.CompressionType#UNCOMPRESSED}.
       *
       *
A {@code null} value will reset the value to the default value mentioned above.
       *
       *
Does not modify this object.
       *
       * @param writableByteChannelFactory the factory to be used during output
       */
      public Bound<T> withWritableByteChannelFactory(
          WritableByteChannelFactory writableByteChannelFactory) {
        return new Bound<>(name, filenamePrefix, filenameSuffix, header, footer, coder, numShards,
            shardTemplate, validate, writableByteChannelFactory);
      }

      @Override
      public PDone expand(PCollection<T> input) {
        if (filenamePrefix == null) {
          throw new IllegalStateException(
              "need to set the filename prefix of a TextIO.Write transform");
        }
        org.apache.beam.sdk.io.Write.Bound<T> write =
            org.apache.beam.sdk.io.Write.to(
                new TextSink<>(filenamePrefix, filenameSuffix, header, footer, shardTemplate,
                    coder, writableByteChannelFactory));
        if (getNumShards() > 0) {
          write = write.withNumShards(getNumShards());
        }
        return input.apply("Write", write);
      }

      @Override
      public void populateDisplayData(DisplayData.Builder builder) {
        super.populateDisplayData(builder);

        String prefixString = filenamePrefix.isAccessible()
            ? filenamePrefix.get() : filenamePrefix.toString();
        builder
            .addIfNotNull(DisplayData.item("filePrefix", prefixString)
              .withLabel("Output File Prefix"))
            .addIfNotDefault(DisplayData.item("fileSuffix", filenameSuffix)
              .withLabel("Output Fix Suffix"), "")
            .addIfNotDefault(DisplayData.item("shardNameTemplate", shardTemplate)
              .withLabel("Output Shard Name Template"),
                DEFAULT_SHARD_TEMPLATE)
            .addIfNotDefault(DisplayData.item("validation", validate)
              .withLabel("Validation Enabled"), true)
            .addIfNotDefault(DisplayData.item("numShards", numShards)
              .withLabel("Maximum Output Shards"), 0)
            .addIfNotNull(DisplayData.item("fileHeader", header)
              .withLabel("File Header"))
            .addIfNotNull(DisplayData.item("fileFooter", footer)
                .withLabel("File Footer"))
            .add(DisplayData
                .item("writableByteChannelFactory", writableByteChannelFactory.toString())
                .withLabel("Compression/Transformation Type"));
      }

      /**
       * Returns the current shard name template string.
       */
      public String getShardNameTemplate() {
        return shardTemplate;
      }

      @Override
      protected Coder<Void> getDefaultOutputCoder() {
        return VoidCoder.of();
      }

      public String getFilenamePrefix() {
        return filenamePrefix.get();
      }

      public String getShardTemplate() {
        return shardTemplate;
      }

      public int getNumShards() {
        return numShards;
      }

      public String getFilenameSuffix() {
        return filenameSuffix;
      }

      public Coder<T> getCoder() {
        return coder;
      }

      @Nullable
      public String getHeader() {
        return header;
      }

      @Nullable
      public String getFooter() {
        return footer;
      }

      public boolean needsValidation() {
        return validate;
      }
    }
  }

  /**
   * Possible text file compression types.
   */
  public enum CompressionType {
    /**
     * Automatically determine the compression type based on filename extension.
     */
    AUTO(""),
    /**
     * Uncompressed (i.e., may be split).
     */
    UNCOMPRESSED(""),
    /**
     * GZipped.
     */
    GZIP(".gz"),
    /**
     * BZipped.
     */
    BZIP2(".bz2"),
    /**
     * Zipped.
     */
    ZIP(".zip");

    private String filenameSuffix;

    CompressionType(String suffix) {
      this.filenameSuffix = suffix;
    }

    /**
     * Determine if a given filename matches a compression type based on its extension.
     * @param filename the filename to match
     * @return true iff the filename ends with the compression type's known extension.
     */
    public boolean matches(String filename) {
      return filename.toLowerCase().endsWith(filenameSuffix.toLowerCase());
    }
  }

  // Pattern which matches old-style shard output patterns, which are now
  // disallowed.
  private static final Pattern SHARD_OUTPUT_PATTERN = Pattern.compile("@([0-9]+|\\*)");

  private static void validateOutputComponent(String partialFilePattern) {
    checkArgument(
        !SHARD_OUTPUT_PATTERN.matcher(partialFilePattern).find(),
        "Output name components are not allowed to contain @* or @N patterns: "
        + partialFilePattern);
  }

  //////////////////////////////////////////////////////////////////////////////

  /** Disable construction of utility class. */
  private TextIO() {}

  /**
   * A {@link FileBasedSource} which can decode records delimited by newline characters.
   *
   *
This source splits the data into records using {@code UTF-8} {@code \n}, {@code \r}, or
   * {@code \r\n} as the delimiter. This source is not strict and supports decoding the last record
   * even if it is not delimited. Finally, no records are decoded if the stream is empty.
   *
   *
This source supports reading from any arbitrary byte position within the stream. If the
   * starting position is not {@code 0}, then bytes are skipped until the first delimiter is found
   * representing the beginning of the first record to be decoded.
   */
  @VisibleForTesting
  static class TextSource<T> extends FileBasedSource<T> {
    /** The Coder to use to decode each line. */
    private final Coder<T> coder;

    @VisibleForTesting
    TextSource(String fileSpec, Coder<T> coder) {
      super(fileSpec, 1L);
      this.coder = coder;
    }

    @VisibleForTesting
    TextSource(ValueProvider<String> fileSpec, Coder<T> coder) {
      super(fileSpec, 1L);
      this.coder = coder;
    }

    private TextSource(String fileName, long start, long end, Coder<T> coder) {
      super(fileName, 1L, start, end);
      this.coder = coder;
    }

    @Override
    protected FileBasedSource<T> createForSubrangeOfFile(String fileName, long start, long end) {
      return new TextSource<>(fileName, start, end, coder);
    }

    @Override
    protected FileBasedReader<T> createSingleFileReader(PipelineOptions options) {
      return new TextBasedReader<>(this);
    }

    @Override
    public boolean producesSortedKeys(PipelineOptions options) throws Exception {
      return false;
    }

    @Override
    public Coder<T> getDefaultOutputCoder() {
      return coder;
    }

    /**
     * A {@link org.apache.beam.sdk.io.FileBasedSource.FileBasedReader FileBasedReader}
     * which can decode records delimited by newline characters.
     *
     *
See {@link TextSource} for further details.
     */
    @VisibleForTesting
    static class TextBasedReader<T> extends FileBasedReader<T> {
      private static final int READ_BUFFER_SIZE = 8192;
      private final Coder<T> coder;
      private final ByteBuffer readBuffer = ByteBuffer.allocate(READ_BUFFER_SIZE);
      private ByteString buffer;
      private int startOfSeparatorInBuffer;
      private int endOfSeparatorInBuffer;
      private long startOfRecord;
      private volatile long startOfNextRecord;
      private volatile boolean eof;
      private volatile boolean elementIsPresent;
      private T currentValue;
      private ReadableByteChannel inChannel;

      private TextBasedReader(TextSource<T> source) {
        super(source);
        coder = source.coder;
        buffer = ByteString.EMPTY;
      }

      @Override
      protected long getCurrentOffset() throws NoSuchElementException {
        if (!elementIsPresent) {
          throw new NoSuchElementException();
        }
        return startOfRecord;
      }

      @Override
      public long getSplitPointsRemaining() {
        if (isStarted() && startOfNextRecord >= getCurrentSource().getEndOffset()) {
          return isDone() ? 0 : 1;
        }
        return super.getSplitPointsRemaining();
      }

      @Override
      public T getCurrent() throws NoSuchElementException {
        if (!elementIsPresent) {
          throw new NoSuchElementException();
        }
        return currentValue;
      }

      @Override
      protected void startReading(ReadableByteChannel channel) throws IOException {
        this.inChannel = channel;
        // If the first offset is greater than zero, we need to skip bytes until we see our
        // first separator.
        if (getCurrentSource().getStartOffset() > 0) {
          checkState(channel instanceof SeekableByteChannel,
              "%s only supports reading from a SeekableByteChannel when given a start offset"
              + " greater than 0.", TextSource.class.getSimpleName());
          long requiredPosition = getCurrentSource().getStartOffset() - 1;
          ((SeekableByteChannel) channel).position(requiredPosition);
          findSeparatorBounds();
          buffer = buffer.substring(endOfSeparatorInBuffer);
          startOfNextRecord = requiredPosition + endOfSeparatorInBuffer;
          endOfSeparatorInBuffer = 0;
          startOfSeparatorInBuffer = 0;
        }
      }

      /**
       * Locates the start position and end position of the next delimiter. Will
       * consume the channel till either EOF or the delimiter bounds are found.
       *
       *
This fills the buffer and updates the positions as follows:
       *
{@code
       * ------------------------------------------------------
       * | element bytes | delimiter bytes | unconsumed bytes |
       * ------------------------------------------------------
       * 0            start of          end of              buffer
       *              separator         separator           size
       *              in buffer         in buffer
       * }

       */
      private void findSeparatorBounds() throws IOException {
        int bytePositionInBuffer = 0;
        while (true) {
          if (!tryToEnsureNumberOfBytesInBuffer(bytePositionInBuffer + 1)) {
            startOfSeparatorInBuffer = endOfSeparatorInBuffer = bytePositionInBuffer;
            break;
          }

          byte currentByte = buffer.byteAt(bytePositionInBuffer);

          if (currentByte == '\n') {
            startOfSeparatorInBuffer = bytePositionInBuffer;
            endOfSeparatorInBuffer = startOfSeparatorInBuffer + 1;
            break;
          } else if (currentByte == '\r') {
            startOfSeparatorInBuffer = bytePositionInBuffer;
            endOfSeparatorInBuffer = startOfSeparatorInBuffer + 1;

            if (tryToEnsureNumberOfBytesInBuffer(bytePositionInBuffer + 2)) {
              currentByte = buffer.byteAt(bytePositionInBuffer + 1);
              if (currentByte == '\n') {
                endOfSeparatorInBuffer += 1;
              }
            }
            break;
          }

          // Move to the next byte in buffer.
          bytePositionInBuffer += 1;
        }
      }

      @Override
      protected boolean readNextRecord() throws IOException {
        startOfRecord = startOfNextRecord;
        findSeparatorBounds();

        // If we have reached EOF file and consumed all of the buffer then we know
        // that there are no more records.
        if (eof && buffer.size() == 0) {
          elementIsPresent = false;
          return false;
        }

        decodeCurrentElement();
        startOfNextRecord = startOfRecord + endOfSeparatorInBuffer;
        return true;
      }

      /**
       * Decodes the current element updating the buffer to only contain the unconsumed bytes.
       *
       *
This invalidates the currently stored {@code startOfSeparatorInBuffer} and
       * {@code endOfSeparatorInBuffer}.
       */
      private void decodeCurrentElement() throws IOException {
        ByteString dataToDecode = buffer.substring(0, startOfSeparatorInBuffer);
        currentValue = coder.decode(dataToDecode.newInput(), Context.OUTER);
        elementIsPresent = true;
        buffer = buffer.substring(endOfSeparatorInBuffer);
      }

      /**
       * Returns false if we were unable to ensure the minimum capacity by consuming the channel.
       */
      private boolean tryToEnsureNumberOfBytesInBuffer(int minCapacity) throws IOException {
        // While we aren't at EOF or haven't fulfilled the minimum buffer capacity,
        // attempt to read more bytes.
        while (buffer.size() <= minCapacity && !eof) {
          eof = inChannel.read(readBuffer) == -1;
          readBuffer.flip();
          buffer = buffer.concat(ByteString.copyFrom(readBuffer));
          readBuffer.clear();
        }
        // Return true if we were able to honor the minimum buffer capacity request
        return buffer.size() >= minCapacity;
      }
    }
  }

  /**
   * A {@link FileBasedSink} for text files. Produces text files with the newline separator
   * {@code '\n'} represented in {@code UTF-8} format as the record separator.
   * Each record (including the last) is terminated.
   */
  @VisibleForTesting
  static class TextSink<T> extends FileBasedSink<T> {
    private final Coder<T> coder;
    @Nullable private final String header;
    @Nullable private final String footer;

    @VisibleForTesting
    TextSink(
        ValueProvider<String> baseOutputFilename, String extension,
        @Nullable String header, @Nullable String footer,
        String fileNameTemplate, Coder<T> coder,
        WritableByteChannelFactory writableByteChannelFactory) {
      super(baseOutputFilename, extension, fileNameTemplate, writableByteChannelFactory);
      this.coder = coder;
      this.header = header;
      this.footer = footer;
    }

    @Override
    public FileBasedSink.FileBasedWriteOperation<T> createWriteOperation(PipelineOptions options) {
      return new TextWriteOperation<>(this, coder, header, footer);
    }

    /**
     * A {@link org.apache.beam.sdk.io.FileBasedSink.FileBasedWriteOperation
     * FileBasedWriteOperation} for text files.
     */
    private static class TextWriteOperation<T> extends FileBasedWriteOperation<T> {
      private final Coder<T> coder;
      @Nullable private final String header;
      @Nullable private final String footer;

      private TextWriteOperation(TextSink<T> sink, Coder<T> coder,
          @Nullable String header, @Nullable String footer) {
        super(sink);
        this.coder = coder;
        this.header = header;
        this.footer = footer;
      }

      @Override
      public FileBasedWriter<T> createWriter(PipelineOptions options) throws Exception {
        return new TextWriter<>(this, coder, header, footer);
      }
    }

    /**
     * A {@link org.apache.beam.sdk.io.FileBasedSink.FileBasedWriter FileBasedWriter}
     * for text files.
     */
    private static class TextWriter<T> extends FileBasedWriter<T> {
      private static final byte[] NEWLINE = "\n".getBytes(StandardCharsets.UTF_8);
      private final Coder<T> coder;
      @Nullable private final String header;
      @Nullable private final String footer;
      private OutputStream out;

      public TextWriter(FileBasedWriteOperation<T> writeOperation, Coder<T> coder,
          @Nullable String header, @Nullable String footer) {
        super(writeOperation);
        this.header = header;
        this.footer = footer;
        this.mimeType = MimeTypes.TEXT;
        this.coder = coder;
      }

      /**
       * Writes {@code value} followed by a newline if {@code value} is not null.
       */
      private void writeIfNotNull(@Nullable String value) throws IOException {
        if (value != null) {
          out.write(value.getBytes(StandardCharsets.UTF_8));
          out.write(NEWLINE);
        }
      }

      @Override
      protected void prepareWrite(WritableByteChannel channel) throws Exception {
        out = Channels.newOutputStream(channel);
      }

      @Override
      protected void writeHeader() throws Exception {
        writeIfNotNull(header);
      }

      @Override
      protected void writeFooter() throws Exception {
        writeIfNotNull(footer);
      }

      @Override
      public void write(T value) throws Exception {
        coder.encode(value, out, Context.OUTER);
        out.write(NEWLINE);
      }
    }
  }
}

redpajama_set_name: RedPajamaGithub


Spain's Prime Minister Mariano Rajoy.
MADRID (Reuters) - Spanish conservative leader Mariano Rajoy was sworn in as prime minister on Monday by King Felipe, after more than 10 months of political jockeying to form a government following two inconclusive elections.
Rajoy, leader of the People's Party, is returning to power after losing his absolute majority, and will have to strike deals with opposition parties to pass legislation in a fragmented and hostile parliament.


text:
Q: Updating my shopping cart list in android I'm developing a shopping cart app in Android and i followed this tutorial http://www.androiddom.com/2011/06/android-shopping-cart-tutorial-part-2.html
and I am facing one problem now.
When I set a quantity of an item and click setquantity, it adds the item to the list SHOPPING_CART_ACTIVITY, but if I want to change the quantity now, I should click the same item in the cart and it will redirect me to the specific item's page, PRODUCT_DETAILS_ACTIVITY.
However if I change the quantity, it takes it to be a new quantity. and even the old one exists.
I have checked the entire code, and I think a flaw occurs in PRODUCT_DETAILS_ACTIVITY (a new object is created every time). I tried the notifyDataSetChanged but it was of no use.
Can somebody please tell what can be done?
shoppingcartactivity.(here appears the  final list of products in the cart and clicking on an item in the list will redirect me to that particular page)
final ListView listViewCatalog = (ListView) findViewById(R.id.ListViewCatalog);
    mProductAdapter = new ProductAdapter(mCartList, getLayoutInflater(), true);
    listViewCatalog.setAdapter(mProductAdapter);

    listViewCatalog.setOnItemClickListener(new OnItemClickListener() {

        @Override
        public void onItemClick(AdapterView<?> parent, View view, int position,
                long id) {
            Intent productDetailsIntent = new Intent(getBaseContext(),ProductDetailsActivity.class);
            productDetailsIntent.putExtra(ShoppingCartHelper.PRODUCT_INDEX, position);
            startActivity(productDetailsIntent);
        }
    });

}

@Override
protected void onResume() {
    super.onResume();

    // Refresh the data
    if(mProductAdapter != null) {
        mProductAdapter.notifyDataSetChanged();
    }
}

productdetailsactivity. Each time when I click an item in the cart to change quantity, it treats to be a new entry (so it shows that currently in cart is 0) every time and the previous quantity item ie the old item is also present.
    // inside onCreate method....
    LayoutInflater li;

    int productIndex = getIntent().getExtras().getInt(
            ShoppingCartHelper.PRODUCT_INDEX);

    String PRODUCT_STRING="";
    PRODUCT_STRING = getIntent().getExtras().getString("PRODUCT_STRING");

    switch (PRODUCT_STRING)
    {
    case "Laptops":
    //  catalog = get laptop catalog
        break;

    case "Phones":

    //  catalog = get phones catalog
        break;
    }

    final Product selectedProduct = (Product) catalog.get(productIndex);
    Toast.makeText(getApplicationContext(),
             "Inside selected product obj", Toast.LENGTH_SHORT).show();
    productImageView = (ImageView) findViewById(R.id.ImageViewProduct);

    productTitleTextView = (TextView) findViewById(R.id.TextViewProductTitle);

    productDetailsTextView = (TextView) findViewById(R.id.TextViewProductDetails);

    productImageView.setImageDrawable(selectedProduct.productImage);

    productTitleTextView.setText(selectedProduct.title);
    productDetailsTextView.setText(selectedProduct.description);

    // Update the current quantity in the cart
    TextView textViewCurrentQuantity = (TextView) findViewById(R.id.textViewCurrentlyInCart);

    textViewCurrentQuantity.setText("Currently in Cart: "
            + ShoppingCartHelper.getProductQuantity(selectedProduct));

    Toast.makeText(getApplicationContext(), "quantity "+ ShoppingCartHelper.getProductQuantity(selectedProduct),
            Toast.LENGTH_SHORT).show();

    // Save a reference to the quantity edit text
     final EditText editTextQuantity = (EditText) findViewById(R.id.editTextQuantity);
    Button setQuantity = (Button) findViewById(R.id.ButtonAddToCart);
    setQuantity.setOnClickListener(new OnClickListener() {
        public void onClick(View v) {
            quantity = Integer.parseInt(editTextQuantity.getText().toString());
            ShoppingCartHelper.setQuantity(selectedProduct, quantity);
            finish();
        }
    });
}

shopping cart helper.....
public static void setQuantity(Product product, int quantity) {
    // Get the current cart entry
    ShoppingCartEntry curEntry = cartMap.get(product);   gives null for the every entry

    // If the quantity is zero or less, remove the products
    if(quantity <= 0) {
        if(curEntry != null)
            removeProduct(product);
        return;
    }

    // If a current cart entry doesn't exist, create one
    if(curEntry == null) {
        curEntry = new ShoppingCartEntry(product, quantity);
        cartMap.put(product, curEntry);
        return;
    }

    // Update the quantity
    curEntry.setQuantity(quantity);
}

public static int getProductQuantity(Product product) {
    // Get the current cart entry
    ShoppingCartEntry curEntry = cartMap.get(product);

    if(curEntry != null)
        return curEntry.getQuantity();

    return 0;
}

public static void removeProduct(Product product) {
    cartMap.remove(product);
}

public static List<Product> getCartList() {
    List<Product> cartList = new Vector<Product>(cartMap.keySet().size());
    for(Product p : cartMap.keySet()) {
        cartList.add(p);
    }

    return cartList;
}
}

productadapter.
@Override
public View getView(int position, View convertView, ViewGroup parent) {
    final ViewItem item;

    if (convertView == null) {
        convertView = mInflater.inflate(R.layout.item, null);
        item = new ViewItem();

        item.productImageView = (ImageView) convertView
                .findViewById(R.id.ImageViewItem);

        item.productTitle = (TextView) convertView
                .findViewById(R.id.TextViewItem);

        item.productQuantity = (TextView) convertView
                .findViewById(R.id.textViewQuantity);

        convertView.setTag(item);
    } else {
        item = (ViewItem) convertView.getTag();
    }

    Product curProduct = mProductList.get(position);

    item.productImageView.setImageDrawable(curProduct.productImage);
    item.productTitle.setText(curProduct.title);

    // Show the quantity in the cart or not

    if (mShowQuantity) {
        item.productQuantity.setText("Quantity: "
                + ShoppingCartHelper.getProductQuantity(curProduct));
    } else {
        // Hid the view
        item.productQuantity.setVisibility(View.GONE);
    }

    return convertView;
}

private class ViewItem {
    ImageView productImageView;
    TextView productTitle;
    TextView productQuantity;
}


For most people, there comes a time when the boat must be put away for the season, the cabin locked up and all is left to fend for itself through the slumber of the winter. In most locations, you will use a boat cover or store a small boat in open or unheated storage. Larger boats will be secured to the dock or hauled out and winterized. The number one thing that people complain about is the smell when you get back to the boat in the spring. Go2marine is here to offer you some understanding about what happens during the winter with moisture and what can be done to protect your boat.
If your boat is small, you should first get a boat cover to protect the topsides and interior from weather and reduce moisture coming in from the environment. If your boat is large, you will need to seal it up well; yet still supply some form of ventilation. The number one enemy of the interior of boats in the off season is moisture.
Fungus (Fungi) consist of molds, mildews, yeasts and more, in this unique Kingdom that is neither animal nor plant. Fungi are part of the natural environment and operate primarily by breaking down dead organic matter such as fallen leaves and dead trees. Indoors, fungus growth tries to break down dead matter (wood, cotton, rayon and other organic materials) as well as pseudo-organic materials (like foam, polyester). Fungi reproduce by many means, including tiny spores; the spores are invisible to the naked eye and float through outdoor and indoor air. The more commonly recognizable mold and mildew may begin growing indoors when mold spores land on surfaces that are wet. There are many types of mold, and few of them will grow without water or moisture. This Kingdom makes up the most diverse life on the planet with worldwide distribution and some 1.5 million species. Fungi also has the ability to become an allergen, irritant or significant pathogen to humans.
Fungi gradually destroy the things that they grow on. Ultimately Fungi thrive as a result of a high level of moisture encouraging their growth; rather than trying to just treat the fungi to kill them, resolve the moisture issue to prevent the problem that encourages Fungi growth.
Requiring Power – For boats that are left within the reach of an extension cord or dock cord you can help keep moisture to a minimum with a number of heater or dehumidifier options.
GoldenRod Dehumidifiers offer inherent safety features like no fan, simple installation, constant heat output and simplicity. They eliminate dampness, mildew, condensation and humidity with size options for areas from 100 to 500 cubic feet.
Extreme (Xtreme) Heaters takes a higher tech, more active approach to keeping moisture in control. The XtremeHeater Boat Heater is a heating element that is self-regulated at a pre-set temperature and automatically varies its wattage in order to maintain that pre-set temperature.
Non-Powered – If you leave your boat and there is no means to power anything, you still have several options.
Hard mounting vents are are installed in the cabin top or on hatches and used when leaving your vessel for the season, while it is uncovered but still weather-tite. The big news here is solar vents that have the advantage of a fan without leading power wires.
There are a variety of moisture control devices that rely on a 'salt' like Calcium Chloride to draw moisture from the surrounding air and can be used in nearly any location, onboard or under cover. The most common of these is the Dri-Z-Air Dehumidifier.
Lastly, if you have a boat cover, a vent with support pole can help in any season with moisture control. This system is easily installed with a pair of scissors and your hands for a clean vent installation.
Boat Covers for the Fall & Winter – and years to come!
In Need of a New Boat Cover?
In most areas of the country, the summer season of boating is drawing to a close. Protect your boat with a new boat cover from Go2marine; all major boat cover manufacturers are covered here! At Go2marine, we would like to share some ideas and information to help you choose and use your boat cover… lest your cover end up like this sad picture.
There are a number of things that can be done to extend the life of your boat cover and the ability to protect the investment in your boat. You will need to make choices for a cover based on your local, environmental and storage conditions – then on the boat cover fabric.
Poly/cotton (65/35) blends are the least expensive fabric, typically, they are warranted for only a year.
Acrylic is the top end material, usually only in heavier weight fabrics (9 0z. plus).
Boat cover manufacturers and their fabrics: Manufacturer – Fabric Name, Material, Weight and Warranty.
Taylor Made – Ultima, Polyester, 7 oz., 5 year.
Westland – Sunbrella, Acrylic, 9.25 oz., 5 year.
ShoreMaster – Prism, Polyester, 9 oz., 5 year.
Carver – Poly-Guard, Polyester, 8 oz., 5 year.
Taylor Made – Hot Shot, Polyester, 6.25 oz., 5 year.
Westland– Sharkskin, Polyester, 6.5 oz., 5 year.
ShoreMaster – Sunburst, Polyester, 6.5 oz., 3 year.
Where you store your boat and the environmental conditions it is subjected to will affect the life of the cover. How you set up the cover for storage with one of the many options, will also effect the usefulness and longevity of the boat cover.
Get a strap system. This is useful for the large cockpit expanse on most boats and will prevent the huge, tearing puddle that can happen. Mounts at four corners connecting at the center with a pad on pole arrangement.
Remember: Choose the fabric for the cover that will last the best for your application. If the boat is stored outside, year round, tailored or subjected to harsh conditions then a Top of the line fabric is what you want. If your boat is stored under a carport, on a lift and you are usually good with handling the cover, get the middle range line of fabrics. Lastly, if you are just looking for a "dust cover" to protect your boat while stored, then the base poly/cotton cover will work fine.
For all your boat cover needs, contact Go2marine.


text:
  <meta charset="utf-8">
  <title>5 Reasons I Know I am Choosing the Right Path</title>
  <meta name="description" content="5 Reasons I Know I am Choosing the Right Path">
  <meta name="author" content="Tom Walker">

  <meta name="viewport" content="width=device-width, initial-scale=1">

  <link href="//fonts.googleapis.com/css?family=Raleway:400,300,600" rel="stylesheet" type="text/css">
  <link rel="stylesheet" href="http://imgone98.com/css/fonts.css">

  <link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/pure/0.6.0/pure-min.css">

    <link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/pure/0.6.0/grids-responsive-min.css">

  <link rel="stylesheet" href="http://imgone98.com/css/custom.css">

  <link rel="stylesheet" href="http://imgone98.com/highlight/styles/default.css">

            ImGone98

                    Adventures

                    History-Religion

                    Introspection

                    Nerdy

                    About

            ImGone98
            ☰

                    Adventures

                    History-Religion

                    Introspection

                    Nerdy

                    About

                    <time class="">2017-01-04</time>

                    |

                    categories:introspection

5 Reasons I Know I am Choosing the Right Path

Alright, let me take a step back for a minute. I’m telling myself that I can succeed at something so many others have failed at. What makes me think I can achieve victory in this expenditure? Not to mention the fact I plan to not spend money, to hide it from family and friends and therefore receive little to no support, and .

I would try to argue that this blog is for me. Well, it is. There’s really not much arguing to it. It is a blog for me. It’s is for me in the sense that I become happy when I help people with their problems and inspiring them to do amazing things.

I’m fairly certain I’m not the only one to start a blog with those intents. I’m sure plenty have failed. So what makes me think I will succeed? My childhood fantasies, my dedication proven through education and athletic abilities, my ability to focus on the task at hand, and my understanding that I will probably never get directly paid to write these.

Please enable JavaScript to view the comments powered by Disqus.
comments powered by Disqus

Tom Walker:

                    GitHub

            ↑↑


On Saturday, country singer Amy Wilcox, 25, will be in town to debut her first album. After wrapping up her studies at Vanderbilt, the Virginia native spent a year performing at Nashville's premier music venue, 3rd and Lindsley, while also working with some of the best writers in the industry. Amy just crafted a debut album, with producer Alan Bennett, that is filled with unforgettable songs that prove she is here to stay. Possessing a warm, honest voice that is as strong as it is playful, her lively and deep spirit leaves you wanting more. Learn more about Amy and listen to her music at AmyWilcox.com.
Guest of a Guest will be at her DC debut show this Saturday at Hill Country BBQ Market.


Petcare, here at Gold Hawk Road is one of the oldest operating veterinary practices in London. The practice has been open since the 1930's and was even operating through the war, while having to use blackout blinds.
We are happy to make home visits if you are unable to come to the practice or if your pet is too unwell to travel. However, please bear in mind that all the equipment and resources are based at the practice and we would prefer you to bring your pet to us if at all possible to enable us to provide the optimum treatment.
New puppies and kittens receive a complimentary welcome pack and we offer advice on all aspects of health care and behaviour and answers to any questions that you may have including senior clinics for older pets. Much of our work takes place behind the scenes and you may not witness all the quality of our services, but you can be confident that every one of our patients is treated with compassion and lots of tender loving care. Once again, we welcome you as a client and hope that we are able to meet your expectations of service and provide your pet with the best possible continuing health care.
We have particular interest and experience in treating aquarium fish, avian (bird), exotic species.


text:
Honoring son Cory through a Donor Advised Fund
For the past several years, the Cory McInnis Compassion in Education Fund has been an integral part of the grant awards given by the High Point Community Foundation. Before the fund came to fruition, the McInnis family was looking for a way to honor the memory of their beloved son. Eventually, they decided to establish a donor advised fund, which would allow them to keep Cory's legacy alive while affecting positive change in a community they love.
"Cory was a funny, easy-going young man who faced a tremendous challenge dealing with the debilitating symptoms of Duchenne's muscular dystrophy, and yet, he never complained about his situation. This illness, which ultimately confined him to a wheelchair, did not deter him. He loved being with his friends in the public school system and despite his limitations, he always wanted to be independent. Cory brought out the best in the people around him and, in return, all of his peers looked after him. The schools did so much to help him have a good experience that we wanted to find a way to give back.
"We set up a donor advised fund at the foundation because of the flexibility it offered. The goal of the fund is to support High Point schools. We have some of the poorest schools in the country and we've got some that don't even have a PTA. We thought it would help enhance the lives of those less fortunate and have been pleased with the variety of needs that have been met through the fund. There will always be a need for this fund and thanks to the way it's set up, no one will ever forget who Cory was.
"Our experience with our donor advised fund has been, in a word, wonderful. We don't have to worry about anything. The Grants Committee always does a fine job of assigning the money where it needs to go. This will last forever. We feel comfortable with the way every penny has been used and it has been fun to sit back and watch it happen. I recommend this to anyone who has a specific interest or love for a cause and wants to give over time while having someone else manage the money and process. The leadership is great and there are plenty of options to meet your needs. Nowhere else can you find this option. The High Point Community Foundation is the perfect vehicle for our family."
Jane McInnis, mom
High Point Community Foundation2020-06-02T17:14:45+00:00February 4th, 2015|Giving in Action|
Giving 101 – "The Gift of Life"
"The real heroes are guys like Brad" – Heart of High Point Fund helps food pantry weather the pandemic
Longtime Foundation supporter featured for underwriting HPU chapel renovation
Community partners work with Barnes & Noble donating stacks of books to inspire a love for reading at High Point elementary schools
WGHP tribute to our friend Bill Horney