text
stringlengths 1
22.8M
|
|---|
The Old Baptist Union is a group of evangelical Baptist churches in the United Kingdom.
History
The Old Baptist Union was founded in 1880, owing largely to the labours of Henry Augustus Squire, an itinerant preacher. Currently the Old Baptist Union has 16 member churches (in England and Wales) with about 700 members.
The churches of the Old Baptist Union are General Baptist, believing in general atonement (that in His death, Jesus atoned generally for the sins of all). They historically put more emphasis on the laying on of hands, divine healing and personal holiness than some other Baptist affiliations.
The Union is a member of both the Free Churches Council and the Evangelical Alliance, and most of its churches are members of local geographic Associations of the Baptist Union of Great Britain. Its government structure is somewhat of a combination between congregational and presbyteral, involving in each church the appointment of Elders. The Old Baptist Union's executive body is called the "Council of Management," and is composed of all the ordained officers of churches holding membership in the Union. An Annual General Meeting is held.
Sources
Articles of Faith of the Old Baptist Union
Baptists Around the World, by Albert W. Wardin, Jr.
External links
Official Website
Baptist denominations in the United Kingdom
Religious organizations established in 1880
1880 establishments in the United Kingdom
|
Sara González Rodríguez (born 23 May 1989), known as Sara Tui, is a Spanish footballer who plays as a central midfielder for Italian Serie B club Ternana.
Club career
Tui started her career at Arousana and then later played at Pontevedra, L'Estartit, El Olivo and Granadilla. Tui joined Madrid CFF in 2019. After two seasons at Madrid CFF, she transferred to Italian club Napoli, which was the first time that Tui had signed for a club outside of Spain. She played in the opening game of the Serie A season, a 3–0 defeat to Inter Milan. After two subsequent seasons at Napoli, she signed for Serie B team Ternana.
International career
As a junior international Tui played the 2008 U-19 European Championship.
Personal life and beach soccer career
Tui enjoys drawing in her spare time. She also plays beach soccer. She has been called up to the Spain national beach soccer team.
References
External links
1989 births
Living people
Women's association football midfielders
Spanish women's footballers
People from O Baixo Miño
Sportspeople from the Province of Pontevedra
Liga F players
UE L'Estartit players
Footballers from Pontevedra
UD Granadilla Tenerife players
Madrid CFF players
SSD Napoli Femminile players
Serie A (women's football) players
Spanish expatriate women's footballers
Expatriate women's footballers in Italy
Spanish beach soccer players
Spain women's youth international footballers
European Games gold medalists for Spain
European Games medalists in beach soccer
Beach soccer players at the 2023 European Games
|
Zoe Louise Ball (born 23 November 1970) is a British radio and television presenter. She was the first female host of the Radio 1 and Radio 2 breakfast shows for the BBC, and presented the 1990s children's show Live & Kicking, alongside Jamie Theakston from 1996–1999.
Ball was a contestant in the third series of Strictly Come Dancing. Following this, in 2011 she replaced Claudia Winkleman as host of the BBC Two spin-off show Strictly Come Dancing: It Takes Two until her departure in 2021. Ball also hosted the Strictly Come Dancing Live Tour in 2011 and 2015.
In 2018, Ball was announced as the new host of BBC Radio 2's flagship breakfast show and took over from Chris Evans in January 2019.
Early life
Zoe Ball was born in Blackpool, Lancashire, and grew up in Farnham Common, Buckinghamshire. She is the daughter of the children's TV presenter Johnny Ball and his wife Julia (née Anderson). The couple divorced when Zoe was two.
Ball was educated at Heston Junior School in the district of Hounslow between 1975 and 1978. Her family then moved to Farnham Common in Buckinghamshire. She attended Farnham Common First School and Farnham Common Middle School before moving to Holy Cross Convent School in Chalfont St Peter and Amersham College of Art and Technology.
She also attended the Young Theatre at Beaconsfield where she trained as an actress. Her first TV appearance was as a child in the studio audience of the 1980s Saturday morning children's show, Saturday Superstore, on which her father was appearing as a guest.
Career
Television
Ball began her television career as a runner at Granada Television and researcher for the Cool Cube on BSkyB. She then worked as a researcher for quiz shows for two years. Her presenting jobs have included hosting The Big Breakfast and The Priory on Channel 4, BBC One's Saturday morning children's programme Live & Kicking, and the pre-school programme Playdays. In 1994, Ball presented SMart with Mark Speight and Jay Burridge until she left in 1996. In 1995, Ball hosted Fully Booked for the first series. Between 1996 and 1998, she was a regular presenter on Top of the Pops, usually alternating with fellow presenters and DJs Jayne Middlemiss and Jo Whiley.
Between 1999 and 2001, she was a co-host with Jamie Theakston on the Wednesday night chat/music show The Priory, which was commissioned by Chris Evans's then production company Ginger Productions.
Ball co-hosted the 2002 Brit Awards with Frank Skinner, following which motherhood meant that she took less television work. In 2005, she co-hosted the BBC reality show Strictly Dance Fever. In 2006, Ball co-hosted the ITV programme Extinct, alongside Trevor McDonald.
In January 2007, she presented the second series of ITV's Soapstar Superstar, taking over from Fern Britton and Ben Shephard, who hosted the first series. In March 2007, she hosted the ITV talent search Grease Is the Word.
Alongside Jamie Theakston, Ball presented Channel 5's quiz series Britain's Best Brain in 2009. Ball has guest presented several episodes of The One Show as a stand-in for Alex Jones.
On 4 August 2013, as hostess of a special entitled Doctor Who Live: The Next Doctor, she revealed Peter Capaldi as the incoming Twelfth Doctor and hosted his first interview in that capacity.
In November 2013, she co-hosted the BBC One Children in Need telethon, alongside Sir Terry Wogan, Fearne Cotton, Nick Grimshaw and Tess Daly. In 2014, Ball presented a BBC Two spin-off from The Voice UK called The Voice: Louder on Two. The show aired for one series of ten episodes.
In 2015, Ball hosted EastEnders: Backstage Live, a spin-off show during the EastEnders live week. She co-presented the BBC Young Dancer competition with Darcey Bussell on BBC Two.
She also narrated two ITV Specials, The Nation's Favourite '70s Number One and The Nation's Favourite '80s Number One as well as the BBC One series Don't Tell the Bride. In 2016, Ball co-presented Can't Touch This, a Saturday night game show for BBC One, alongside Ashley Banjo. She also narrated The Nation's Favourite Carpenters Song.
She guest-presented an episode of Film 2016. In 2017, Ball co-presented The Big Family Cooking Showdown with Nadiya Hussain on BBC Two.
Since 2020, Ball has appeared alongside her son Woody Fred Cook on Celebrity Gogglebox.
In 2021, Ball appeared on The Masked Dancer, masked as Llama. She was the sixth celebrity to be unmasked.
On June 16, 2023 she appeared as herself in Episode 1 of the BBC One comedy Queen of Oz. Ball is seen and heard on her radio programme questioning the outrageous antics of spoiled spare to the British crown, Princess Georgiana, played by Catherine Tate.
Strictly Come Dancing and It Takes Two
In October 2005, Ball became a contestant on the third series of the BBC One talent show Strictly Come Dancing, where she was partnered by Ian Waite. Ball and Waite were ranked in third place; they also scored 38/40 (including two tens) for three dances in the series and one in the Christmas special.
In 2011, she took over from Claudia Winkleman as the host of Strictly Come Dancings sister show It Takes Two, airing every weeknight on BBC Two; in 2014, whilst Winkleman was on leave after her daughter suffered serious burn injuries, Ball co-hosted the main show. On 17 May 2021, Ball announced she was leaving her role as presenter after 10 years.
Radio
Although known primarily for her TV work, Ball first worked in radio, after she became co-host of Radio 1 Breakfast on BBC Radio 1 in October 1997 with Kevin Greening. She became the sole host, the first female DJ to do so. At this time, her hard-drinking, hard-partying lifestyle contributed to the identification of the so-called "ladette culture" of the late 1990s. She was twice warned by the BBC for swearing on the radio.
Ball left BBC Radio 1 in March 2000 to start a family and a new chapter. Her final show was on 10 March 2000; she was succeeded by Sara Cox.
Ball returned to radio in mid-2002 when she joined London radio station Xfm, where she presented the weekday drivetime show until December 2003. In January 2004, she took over a Friday evening music show for the station. She also stood in for Ricky Gervais while he filmed the second series of The Office. She left Xfm at the end of 2004.
In September 2007, she returned to BBC Radio and co-hosted a show with Sara Cox, celebrating 40 years of BBC Radio 1 and BBC Radio 2.
From 2006, she provided relief presenting duties for BBC Radio 2, fronted specialist documentaries, sat in for Dermot O'Leary for three weeks in February 2006, and co-presented (with Danny Baker) the hastily conceived replacement for Jonathan Ross' Saturday morning show, in the wake of Ross's suspension due to Sachsgate in 2008.
In 2009, Ball became the usual relief presenter for Ken Bruce's weekday mid-morning show on BBC Radio 2. She also began hosting the Saturday breakfast show from 6:00 a.m. to 8:00 a.m. on the network from 6 June 2009 as part of a shake-up of weekend programming at Radio 2. Ball left Radio 2 for a while as her last show was broadcast on Saturday 28 January 2012. Her replacement in that slot was Anneka Rice.
Ball covered The Radio 2 Breakfast Show for Chris Evans on several occasions.
From 4 March 2017 until 22 December 2018, Ball returned to Radio 2 on permanent basis where she presented the Saturday afternoon slot on BBC Radio 2 between 3–6pm, taking over from Dermot O'Leary.
On 3 October 2018, she was announced by Chris Evans as the new host of The Radio 2 Breakfast Show, which began on 14 January 2019. Rylan Clark replaced Ball in the Saturday mid-afternoon slot.
Personal life
Whilst at BBC Radio 1, Ball began a relationship with the DJ and musician Norman Cook (also known as Fatboy Slim). The couple married at Babington House in Somerset in August 1999. In 2003, the couple split up when Ball revealed that she had had an affair; they later reconciled. The couple have a son, Woody Fred Cook (born 2000), and a daughter, Nelly (born 2010). On 24 September 2016, the couple announced their separation after 18 years together, and later divorced. Ball's long-term partner Michael Reed is a fashion model and a carpenter; they met through a mutual friend in 2017.
Charity work
In 2014, she supported Marks & Spencer and Oxfam's Love Mum campaign.
In March 2018, Ball took part in the 'Hardest Ride Home' challenge, which saw her cycling from Blackpool to Brighton to raise money for Sport Relief and mental health awareness. She set off on 5 March for five days. Highlights of the challenge were broadcast in a one-off documentary, airing on 21 March 2018 on BBC One. As a result of the challenge, she was able to raise a total of £1,198,012.
Filmography
Radio
Television
References
External links
The Zoe Ball Breakfast Show (BBC Radio 2)
1970 births
BBC Radio 1 presenters
BBC Radio 2 presenters
British children's television presenters
English radio DJs
English television presenters
Living people
People from Blackpool
People from Beaconsfield
Comic Relief people
|
Ballack may refer to:
Michael Ballack (born 1976), retired German footballer
Ballack (footballer, born 1987) (born 1987), Cape Verde footballer
Sainey Touray (born 1990), known as Ballack, Gambian footballer
Luís Germano Pires Lopes de Almeida (born 1990), known as Kiki Ballack, Cape Verde footballer
|
A technical definition is a definition in technical communication describing or explaining technical terminology. Technical definitions are used to introduce the vocabulary which makes communication in a particular field succinct and unambiguous. For example, the iliac crest from medical terminology is the top ridge of the hip bone (see ilium).
Types of technical definitions
There are three main types of technical definitions.
Power definitions
Secondary definitions
Extended definitions
Examples
Aniline, a benzene ring with an amine group, is a versatile chemical used in many organic syntheses.
The genus Helogale (dwarf mongooses) contains two species.
Sentence definitions
These definitions generally appear in three different places: within the text, in margin notes, or in a glossary. Regardless of position in the document, most sentence definitions follow the basic form of term, category, and distinguishing features.
Examples
A major scale is a diatonic scale which has the semitone interval pattern 2-2-1-2-2-2-1.
term: major scale
category: diatonic scales
distinguishing features: semitone interval pattern 2-2-1-2-2-2-1
In mathematics, an abelian group is a group which is commutative.
term: abelian group
category: mathematical groups
distinguishing features: commutative
Extended definitions
When a term needs to be explained in great detail and precision, an extended definition is used. They can range in size from a few sentences to many pages. Shorter ones are usually found in the text, and lengthy definitions are placed in a glossary. Relatively complex concepts in mathematics require extended definitions in which mathematical objects are declared (e.g., let x be a real number...) and then restricted by conditions (often signaled by the phrase such that). These conditions often employ the universal and/or existential quantifiers (for all (), there exists ()).
Note: In mathematical definitions, convention dictates the use of the word if between the term to be defined and the definition; however, definitions should be interpreted as though if and only if were used in place of if.
Examples
Definition of the limit of a single variable function: Let be a real-valued function of a real variable and , , and be real numbers. We say that the limit of as approaches is (or, tends to as approaches ) and write if, for all , there exists such that whenever satisfies , the inequality holds.
References
Technical communication
|
```python
import numpy as np
import torch
from torch import nn
from gans.models.BigGAN import BigGAN
from gans.models.StyleGAN2.model import Generator as StyleGAN2Generator
class ConditionedBigGAN(nn.Module):
def __init__(self, big_gan, target_classes=(239)):
super(ConditionedBigGAN, self).__init__()
self.big_gan = big_gan
self.set_classes(target_classes)
self.dim_z = self.big_gan.dim_z
def set_classes(self, target_classes):
self.target_classes = nn.Parameter(torch.tensor(target_classes, dtype=torch.int64),
requires_grad=False)
def mixed_classes(self, batch_size):
if len(self.target_classes.data.shape) == 0:
return self.target_classes.repeat(batch_size).cuda()
else:
return torch.from_numpy(
np.random.choice(self.target_classes.cpu(), [batch_size])).cuda()
def forward(self, z, classes=None):
if classes is None:
classes = self.mixed_classes(z.shape[0]).to(z.device)
return self.big_gan(z, self.big_gan.shared(classes))
class StyleGAN2Wrapper(nn.Module):
def __init__(self, g, shift_in_w):
super(StyleGAN2Wrapper, self).__init__()
self.style_gan2 = g
self.dim_z = 512
self.dim_shift = self.style_gan2.style_dim if shift_in_w else self.dim_z
self.shift_in_w = shift_in_w
def forward(self, input, w_space=False, noise=None):
if not isinstance(input, list):
input = [input]
return self.style_gan2(input, input_is_latent=w_space, noise=noise)[0]
def make_biggan_config(resolution):
attn_dict = {128: '64', 256: '128', 512: '64'}
dim_z_dict = {128: 120, 256: 140, 512: 128}
config = {
'G_param': 'SN', 'D_param': 'SN',
'G_ch': 96, 'D_ch': 96,
'D_wide': True, 'G_shared': True,
'shared_dim': 128, 'dim_z': dim_z_dict[resolution],
'hier': True, 'cross_replica': False,
'mybn': False, 'G_activation': nn.ReLU(inplace=True),
'G_attn': attn_dict[resolution],
'norm_style': 'bn',
'G_init': 'ortho', 'skip_init': True, 'no_optim': True,
'G_fp16': False, 'G_mixed_precision': False,
'accumulate_stats': False, 'num_standing_accumulations': 16,
'G_eval_mode': True,
'BN_eps': 1e-04, 'SN_eps': 1e-04,
'num_G_SVs': 1, 'num_G_SV_itrs': 1, 'resolution': resolution,
'n_classes': 1000}
return config
def make_big_gan(weights, target_classes=None, resolution=128, n_classes=1000):
config = make_biggan_config(resolution)
config['n_classes'] = n_classes
G = BigGAN.Generator(**config)
G.load_state_dict(torch.load(weights, map_location=torch.device('cpu')), strict=False)
if target_classes is None:
target_classes = np.arange(0, n_classes, 1)
return ConditionedBigGAN(G, target_classes).cuda().eval()
def make_stylegan2(resolution, weights, shift_in_w=True, target_key='g_ema', g_kwargs={}):
G = StyleGAN2Generator(resolution, 512, 8, **g_kwargs)
G.load_state_dict(torch.load(weights)[target_key] if target_key is not None else \
torch.load(weights))
G.cuda().eval()
return StyleGAN2Wrapper(G, shift_in_w=shift_in_w)
```
|
```sqlpl
select
__people__."username" as "0",
(select json_agg(s) from (
select
__single_table_items__."type"::text as "0",
__single_table_items__."parent_id"::text as "1",
__single_table_items__."id"::text as "2",
__single_table_items__."type2"::text as "3",
__single_table_items__."author_id"::text as "4",
__single_table_items__."position"::text as "5",
to_char(__single_table_items__."created_at", 'YYYY-MM-DD"T"HH24:MI:SS.USTZH:TZM'::text) as "6",
to_char(__single_table_items__."updated_at", 'YYYY-MM-DD"T"HH24:MI:SS.USTZH:TZM'::text) as "7",
__single_table_items__."is_explicitly_archived"::text as "8",
to_char(__single_table_items__."archived_at", 'YYYY-MM-DD"T"HH24:MI:SS.USTZH:TZM'::text) as "9",
__single_table_items__."title" as "10",
__single_table_items__."description" as "11",
__single_table_items__."note" as "12",
__single_table_items__."color" as "13"
from interfaces_and_unions.single_table_items as __single_table_items__
where
(
true /* authorization checks */
) and (
__people__."person_id"::"int4" = __single_table_items__."author_id"
)
order by __single_table_items__."id" asc
) s) as "1"
from interfaces_and_unions.people as __people__
where (
true /* authorization checks */
)
order by __people__."person_id" asc;
select __single_table_items_result__.*
from (select ids.ordinality - 1 as idx, (ids.value->>0)::"int4" as "id0" from json_array_elements($1::json) with ordinality as ids) as __single_table_items_identifiers__,
lateral (
select
__single_table_items__."type"::text as "0",
__single_table_items__."type2"::text as "1",
__single_table_items__."author_id"::text as "2",
__single_table_items__."position"::text as "3",
to_char(__single_table_items__."created_at", 'YYYY-MM-DD"T"HH24:MI:SS.USTZH:TZM'::text) as "4",
to_char(__single_table_items__."updated_at", 'YYYY-MM-DD"T"HH24:MI:SS.USTZH:TZM'::text) as "5",
__single_table_items__."is_explicitly_archived"::text as "6",
to_char(__single_table_items__."archived_at", 'YYYY-MM-DD"T"HH24:MI:SS.USTZH:TZM'::text) as "7",
__single_table_items__."title" as "8",
__single_table_items__."description" as "9",
__single_table_items__."note" as "10",
__single_table_items__."color" as "11",
__single_table_items_identifiers__.idx as "12"
from interfaces_and_unions.single_table_items as __single_table_items__
where
(
true /* authorization checks */
) and (
__single_table_items__."id" = __single_table_items_identifiers__."id0"
)
) as __single_table_items_result__;
select __people_result__.*
from (select ids.ordinality - 1 as idx, (ids.value->>0)::"int4" as "id0" from json_array_elements($1::json) with ordinality as ids) as __people_identifiers__,
lateral (
select
__people__."username" as "0",
__people_identifiers__.idx as "1"
from interfaces_and_unions.people as __people__
where
(
true /* authorization checks */
) and (
__people__."person_id" = __people_identifiers__."id0"
)
) as __people_result__;
```
|
A pocket contract is a land-purchase deal that abuses a loophole in the legal restrictions regulating land deals.
The term is mostly used in Hungary. Until May 2014, Hungarian laws did not allow foreigners to purchase Hungarian land. The term originally referred to land deals that omitted the date of the purchase, and the contract was kept ‘in the pocket’ until the land law is changed. The term is now used in a more general sense, and it refers to any contract that aims to circumvent the land laws for the purpose of land grabbing.
The Győr-Moson Sopron County Agricultural Chamber has identified over 16 different types of ‘pocket contract’ over the last decade (some of them have since been excluded due to changes in the Land Tenure Act).
Legal action
In February 2014, the Hungarian parliament approved a modified law on pocket contracts, which sought to make action taken by the authorities against the invalid ownership and misuse of farmland in Hungary more effective.
In May 2014, under an obligation undertaken in its EU accession agreement, Hungary lifted the ban for foreigners on purchasing Hungarian land. However, the country's new land act ensures the possibility of purchasing land practically only to Hungarian farmers. Therefore, many foreigners that purchased Hungarian land in pocket contracts, tried to sell them to Hungarian customers.
References
Abuse of the legal system
Law of Hungary
Land law
|
Western von gestern (lit.: "Yesterday's Western") was a West German movie showcase series that aired on the ZDF network from May 1978 to July 1986.
Concept
Western von gestern was the collective showcase title for a number of American black-and-white Western films and serials from the 1930s to the 1950s. The adaptation script was written by Joe Hembus and Eydo von Hadeln, and the music (which featured original soundtracks, rather than using the originals' musical scores) was composed by Fred Strittmatter and Quirin Amper Jr..
The featured list includes Zorro's Black Whip and several early films with John Wayne, Al St. John (in his popular role as "Fuzzy Jones"), Buster Crabbe and Roy Rogers (Days of Jesse James). However, to accommodate the German TV format, many of the films and serials were edited from their usual 60-minute down to 25-minute features or divided into episodes of similar length. A total of 155 episodes were aired.
One of the show's particularly striking features was the use of Justus D. Barnes' iconic shooting scene from the silent film western The Great Train Robbery - with additionally inserted sound effects - for its intro and final credit sequences.
See also
List of German television series
References
External links
Western von Gestern website
Motion picture television series
1978 German television series debuts
1986 German television series endings
1970s Western (genre) television series
German-language television shows
ZDF original programming
1980s Western (genre) television series
|
Magnificent! is an album by pianist Barry Harris recorded in 1969 and released on the Prestige label.
Reception
Allmusic awarded the album 4 stars with its review by Jim Todd stating, "Magnificent brilliantly illustrates Barry Harris' unique rapport with the bop piano tradition. Absolutely unlike the enervating, curatorial approach of the neo-con movement, Harris deals with the tradition as a continuum, perpetually rejuvenating and extending it".
Awarding the album a maximum four-star rating, The Penguin Guide to Jazz identified it as part of their recommended "core collection".
Track listing
All compositions by Barry Harris except as indicated
"Bean and the Boys" (Coleman Hawkins) - 6:41
"You Sweet and Fancy Lady" - 4:04
"Rouge" - 4:15
"Ah-Leu-Cha" (Charlie Parker) - 4:00
"Just Open Your Heart" - 6:05
"Sun Dance" - 4:21
"These Foolish Things" (Harry Link, Holt Marvell, Jack Strachey) - 5:20
"Dexterity" (Parker) - 4:27
Personnel
Barry Harris - piano
Ron Carter - bass
Leroy Williams - drums
References
Barry Harris albums
1969 albums
Prestige Records albums
Albums produced by Don Schlitten
|
```c
// Using hashtable.
// Runtime: O(n + len(trust))
// Space: O(n)
int findJudge(int n, int** trust, int trustSize, int* trustColSize){
int* personsToTrust = calloc(n + 1, sizeof(int));
int* personsFromTrust = calloc(n + 1, sizeof(int));
for(int i = 0; i < trustSize; i++){
int* currentTrust = trust[i];
personsToTrust[currentTrust[1]] += 1;
personsFromTrust[currentTrust[0]] += 1;
}
int potentialJudjeNumber = -1;
for(int i = 1; i < n + 1; i++){
if (personsToTrust[i] == n - 1 && personsFromTrust[i] == 0){
if (potentialJudjeNumber > -1){
return -1;
}
potentialJudjeNumber = i;
}
}
free(personsToTrust);
free(personsFromTrust);
return potentialJudjeNumber;
}
```
|
Julio Herrera may refer to:
Julio Herrera (cyclist) (born 1980), track and road cyclist from Venezuela
Julio Herrera (equestrian) (1911–?), Mexican Olympic horse rider
Julio Herrera (politician), Peruvian politician
Julio César Herrera (born 1977), Cuban track cyclist
Julio Herrera Velutini (born 1971), international banker
Julio Herrera y Obes (1841–1912), Uruguayan political figure
Julio Herrera y Reissig (1875–1910), Uruguayan poet, playwright and essayist
|
```objective-c
// Iso/Handler.h
#ifndef __ISO_HANDLER_H
#define __ISO_HANDLER_H
#include "Common/MyCom.h"
#include "../IArchive.h"
#include "IsoItem.h"
#include "IsoIn.h"
namespace NArchive {
namespace NIso {
class CHandler:
public IInArchive,
public CMyUnknownImp
{
public:
MY_UNKNOWN_IMP1(
IInArchive
)
INTERFACE_IInArchive(;)
private:
CMyComPtr<IInStream> _inStream;
CInArchive _archive;
};
}}
#endif
```
|
Yellow Bluff Fort Historic State Park is a Florida State Park in Jacksonville, Florida. It is located near the mouth of the St. Johns River, a mile south of State Road 105 on New Berlin Road, in the cities Northside area. On September 29, 1970, it was added to the U.S. National Register of Historic Places.
History
Yellow Bluff 'Fort' was not a fort at all, but instead an armed and fortified camp constructed during the Civil War. It served to protect shipping supply lines to Jacksonville and through the St. Johns valley from Union attacks. The camp was built in early 1862, holding over 350 personnel at some points of its existence, which lasted until the end of the war.
Recreational activities
Visitors can picnic in an authentic reproduction of a Confederate and Union troop encampment.
Special events
Every year, the park has a day of illustrated presentations and living history demonstrations showing the historical and cultural significance of the area.
Admission and hours
There are no entrance fees. The park is open 24 hours a day.
References
External links
Yellow Bluff Fort Historic State Park at Florida State Parks
Yellow Bluff Fort Historic State Park at State Parks
Duval County listings at National Register of Historic Places
Duval County listings at Florida's Office of Cultural and Historical Programs
Yellow Bluff Fort Historic State Park - plans at Florida Department of Environmental Protection
Yellow Bluff
State parks of Florida
National Register of Historic Places in Jacksonville, Florida
Parks in Jacksonville, Florida
Protected areas established in 1970
Yellow
Northside, Jacksonville
1970 establishments in Florida
American Civil War on the National Register of Historic Places
|
The Lonesome Boatman is a 1969 album by the Irish folk music duo Finbar & Eddie Furey. It is best known for its title track which is played hauntingly on a tin whistle, as well as its version of the traditional ballad Carnlough Bay.
In recent times the song has featured at football matches, most notably performed by fans of Glasgow team, Celtic FC.
In 2017, Dropkick Murphys released a cover of "The Lonesome Boatman" on their album 11 Short Stories of Pain & Glory.
1969 albums
The Fureys albums
|
```xml
import { memoize } from './operators/memoize.js';
import { identity } from '../util/identity.js';
import { isFunction } from '../util/isiterable.js';
import { AsyncIterableX } from './asynciterablex.js';
import { AsyncSink } from './asyncsink.js';
const { isArray } = Array;
function callOrApply<T, R>(fn: (...values: T[]) => R, args: T | T[]): R {
return isArray(args) ? fn(...args) : fn(args);
}
/**
* Creates async-iterable from an event emitter by adding handlers for both listening and unsubscribing from events.
*
* @template TSource The type of elements in the event emitter.
* @param {(handler: (...args: any[]) => void) => void} addHandler The function to add a listener to the source.
* @param {(handler: (...args: any[]) => void) => void} removeHandler The function to remove a listener from the source.
* @returns {AsyncIterableX<TSource>} An async-iterable which contains the data from the underlying events as wrapped by the handlers.
*/
export function fromEventPattern<TSource>(
addHandler: (handler: (...args: any[]) => void) => void,
removeHandler: (handler: (...args: any[]) => void) => void,
resultSelector?: (...args: any[]) => TSource
): AsyncIterableX<TSource> {
if (!isFunction(resultSelector)) {
resultSelector = identity;
}
const sink = new AsyncSink<TSource>();
const handler = (...args: any[]) => sink.write(callOrApply(resultSelector!, args));
addHandler(handler);
const loop = async function* () {
try {
for (let next; !(next = await sink.next()).done; ) {
yield next.value;
}
} finally {
removeHandler(handler);
sink.end();
}
};
return memoize<TSource>()(loop());
}
```
|
This is a timeline of Syrian history, comprising important legal and territorial changes and political events in Syria and its predecessor states. To read about the background to these events, see History of Syria.
Millennia: 1st BC1st–2nd3rd
Centuries: 1st2nd3rd4th5th6th7th8th9th10th11th12th13th14th15th16th17th18th19th20thSee alsoFurther reading
1st century BC
1st century
2nd century
3rd century
4th century
5th century
6th century
7th century
8th century
9th century
10th century
11th century
‘'Poet 'Al Maari' writes 'The Epistle of Forgiveness' amongst other great works.'’
12th century
13th century
14th century
15th century
16th century
17th century
18th century
19th century
Massacre of Aleppo
1860 Mount Lebanon civil war
20th century
21st century
See also
Cities in Syria
Timeline of Aleppo
Timeline of Damascus
Timeline of Hama
Timeline of Latakia
References
BBC – Syria timeline
timelines.ws Extensive timeline – thru 2010, 2011-
Further reading
External links
Syrian
Syrian history timelines
Years in Syria
|
```python
import os
import shutil
import subprocess
from subprocess import Popen
import sys
from tempfile import mkdtemp
import time
import unittest
class AutoreloadTest(unittest.TestCase):
def setUp(self):
self.path = mkdtemp()
def tearDown(self):
try:
shutil.rmtree(self.path)
except OSError:
# Windows disallows deleting files that are in use by
# another process, and even though we've waited for our
# child process below, it appears that its lock on these
# files is not guaranteed to be released by this point.
# Sleep and try again (once).
time.sleep(1)
shutil.rmtree(self.path)
def test_reload_module(self):
main = """\
import os
import sys
from tornado import autoreload
# This import will fail if path is not set up correctly
import testapp
print('Starting')
if 'TESTAPP_STARTED' not in os.environ:
os.environ['TESTAPP_STARTED'] = '1'
sys.stdout.flush()
autoreload._reload()
"""
# Create temporary test application
os.mkdir(os.path.join(self.path, "testapp"))
open(os.path.join(self.path, "testapp/__init__.py"), "w").close()
with open(os.path.join(self.path, "testapp/__main__.py"), "w") as f:
f.write(main)
# Make sure the tornado module under test is available to the test
# application
pythonpath = os.getcwd()
if "PYTHONPATH" in os.environ:
pythonpath += os.pathsep + os.environ["PYTHONPATH"]
p = Popen(
[sys.executable, "-m", "testapp"],
stdout=subprocess.PIPE,
cwd=self.path,
env=dict(os.environ, PYTHONPATH=pythonpath),
universal_newlines=True,
)
out = p.communicate()[0]
self.assertEqual(out, "Starting\nStarting\n")
def test_reload_wrapper_preservation(self):
# This test verifies that when `python -m tornado.autoreload`
# is used on an application that also has an internal
# autoreload, the reload wrapper is preserved on restart.
main = """\
import os
import sys
# This import will fail if path is not set up correctly
import testapp
if 'tornado.autoreload' not in sys.modules:
raise Exception('started without autoreload wrapper')
import tornado.autoreload
print('Starting')
sys.stdout.flush()
if 'TESTAPP_STARTED' not in os.environ:
os.environ['TESTAPP_STARTED'] = '1'
# Simulate an internal autoreload (one not caused
# by the wrapper).
tornado.autoreload._reload()
else:
# Exit directly so autoreload doesn't catch it.
os._exit(0)
"""
# Create temporary test application
os.mkdir(os.path.join(self.path, "testapp"))
init_file = os.path.join(self.path, "testapp", "__init__.py")
open(init_file, "w").close()
main_file = os.path.join(self.path, "testapp", "__main__.py")
with open(main_file, "w") as f:
f.write(main)
# Make sure the tornado module under test is available to the test
# application
pythonpath = os.getcwd()
if "PYTHONPATH" in os.environ:
pythonpath += os.pathsep + os.environ["PYTHONPATH"]
autoreload_proc = Popen(
[sys.executable, "-m", "tornado.autoreload", "-m", "testapp"],
stdout=subprocess.PIPE,
cwd=self.path,
env=dict(os.environ, PYTHONPATH=pythonpath),
universal_newlines=True,
)
# This timeout needs to be fairly generous for pypy due to jit
# warmup costs.
for i in range(40):
if autoreload_proc.poll() is not None:
break
time.sleep(0.1)
else:
autoreload_proc.kill()
raise Exception("subprocess failed to terminate")
out = autoreload_proc.communicate()[0]
self.assertEqual(out, "Starting\n" * 2)
```
|
A rollup (also "roll-up" or "roll up") is a process used by investors (commonly private equity firms) where multiple small companies in the same market are acquired and merged.
The principal aim of a rollup is to reduce costs through economies of scale. It also has the effect of increasing the valuation multiples the business can command as it acquires greater scale. Rollups may also have the effect of rationalizing competition in crowded and fragmented markets, where there are often many small participants but room for only a few to succeed.
An investor faced with an opportunity to invest in two competing companies may reduce risk by simply investing in both and merging them. Rollups are often part of the shakeout and consolidation process during an economic downturn or as new market sectors begin to mature.
The characteristics that can make a rollup particularly attractive come into play especially when there are many small players in a fragmented market or in fields where technology can play a role in revitalizing industries with small margins. The other reason companies do rollups is due to the higher earnings multiple achievable in businesses with large scale, compared to smaller mom and pop operations which remain vulnerable to changing markets and poor access to capital markets.
Rollups of complementary or unrelated companies are also done to:
Build a full-capability company, when it would be too costly or time-consuming to develop the missing pieces through internal expansion.
Blending companies have different financial metrics, often to make the combined company attractive for investment, mergers and acquisitions, or an initial public offering.
History
Rollups are almost as old as modern commerce itself, with some early capitalists persuading their competitors to sell out, but reached a peak during the 19th century era of the robber barons, when people like Andrew Carnegie were consolidating the heavy industry and John D. Rockefeller was aggregating the oil industry. James Buchanan Duke bought so many manufacturers that at one point he was controlling 80% of the tobacco business in the US and a huge share of the international trade. These monopolistic attempts worried the authorities and led to a series of anti-trust laws and measures in the early 20th century.
Kraft Foods (now renamed Mondelēz International), which was created in 1923, was an important rollup in the food industry.
Waste Management was the most notable rollup during the 1970s and 1980s. Waste Management's acquisition of 133 small-time haulers quickly became the largest waste disposal company in the US. AutoNation was also a successful rollup effort in the car dealership space spearheaded by Wayne Huizenga, founder of Waste Management.
A recent rollup is Valeant Pharmaceuticals International that used more than $30 billion to acquire over 100 companies.
See also
Ideal firm size
Economies of scale
References
Mergers and acquisitions
Private equity
|
Parker Paul McKenzie (November 15, 1897, near Rainy Mountain – March 5, 1999, Mountain View) was a Kiowa Native American linguist, who developed the Kiowa language orthography used by many today.
Early life
McKenzie was born in a tipi, and baptized in the Washita River. He was educated at the Rainy Mountain Kiowa Boarding School, where it was mandatory to speak the English Language; those who used the Kiowa language were threatened with physical punishment. Afterwards, he attended the Phoenix Indian School, Union High School, Lamson College, and Oklahoma State University.
McKenzie attended the Phoenix Indian School with Nettie Odlety (c. 1896 – 1978), whom he married on August 23, 1919. At school the couple wrote each other letters in Kiowa. They also were some of the earliest Kiowa photographers, taking photographs in Arizona in 1916.
Linguistic work
When in 1918 the Smithsonian Institution sent the anthropologist John Peabody Harrington to Oklahoma to study the language of the Kiowa, McKenzie was his translator. This began a decades-long scientific examination and recording of the Kiowa language, which until then had been purely an oral language. They jointly developed a valid phonetic alphabet, which also resulted in the publication of Vocabulary of the Kiowa Language (1928) and Popular Account of the Kiowa Indian Language (1948), in a collaboration that extended into the 1950s. All this time, from the 1920s to the 1950s, McKenzie, never an academic, was a stenographer in the Indians Monies Section of the Bureau of Indian Affairs.
Late in his life, in close cooperation with Laurel Watkins, McKenzie published A Grammar of Kiowa in 1984. Some compared his work with the development of the Sequoyah and Cherokee alphabets. He also translated many texts from English, including Baptist hymns.
Legacy
His contributions to the Kiowa were honored by the University of Colorado in 1991 with the awarding of an honorary doctorate, and his 100th birthday was honored with a ceremony in the Red Buffalo Hall of the Kiowa Tribal Complex in Carnegie, Oklahoma. McKenzie was a Freemason.
Death
McKenzie died in 1999 at the age of 101 years, and was interred at Anadarko, Oklahoma. After his death, he was elected to the Oklahoma Historians Hall of Fame.
Family
Nettie and Parker had two daughters, Esther Hayes of Mountain View and Kathryn Collier of Wewoka. They also had three sons, William, Henry, and Robert, all deceased.
Notes
1897 births
1999 deaths
Kiowa people
Oklahoma State University alumni
Native American linguists
Native American photographers
People from Kiowa County, Oklahoma
American centenarians
Men centenarians
Linguists of indigenous languages of North America
20th-century linguists
Linguists from the United States
|
```ruby
require_relative '../../spec_helper'
describe "Float#-@" do
it "negates self" do
(2.221.send(:-@)).should be_close(-2.221, TOLERANCE)
-2.01.should be_close(-2.01,TOLERANCE)
-2_455_999_221.5512.should be_close(-2455999221.5512, TOLERANCE)
(--5.5).should be_close(5.5, TOLERANCE)
-8.551.send(:-@).should be_close(8.551, TOLERANCE)
end
it "negates self at Float boundaries" do
Float::MAX.send(:-@).should be_close(0.0 - Float::MAX, TOLERANCE)
Float::MIN.send(:-@).should be_close(0.0 - Float::MIN, TOLERANCE)
end
it "returns negative infinity for positive infinity" do
infinity_value.send(:-@).infinite?.should == -1
end
it "returns positive infinity for negative infinity" do
(-infinity_value).send(:-@).infinite?.should == 1
end
it "returns NaN for NaN" do
nan_value.send(:-@).should.nan?
end
end
```
|
Leandro Carlos Silveira Niehues (born 14 March 1973) is a Brazilian football coach, who is currently the assistant manager of Santo André.
Honours
Inter de Lages
Campeonato Catarinense Série B: 2014
References
External links
Futebol de Goyaz profile
1973 births
Living people
People from Toledo, Paraná
Brazilian football managers
Campeonato Brasileiro Série A managers
Campeonato Brasileiro Série C managers
Club Athletico Paranaense managers
Arapongas Esporte Clube managers
Esporte Clube Internacional de Lages managers
Luverdense Esporte Clube managers
Volta Redonda FC managers
Rio Branco Sport Club managers
Vila Nova Futebol Clube managers
Paysandu Sport Club managers
Operário Ferroviário Esporte Clube managers
Sportspeople from Paraná (state)
|
The Preemption Line (also spelled Pre-Emption) divided the aboriginal lands of western New York State awarded to New York from those awarded to Commonwealth of Massachusetts by the Treaty of Hartford of 1786. It was defined as the meridian (north–south) line from the eighty-second milestone of the Pennsylvania–New York survey line at 76° 57' 58" W northward to Lake Ontario.
Origin and definition
By coincidence, the Preemption Line is near the meridian of the Capitol at Washington (77° 00' 33" W of Greenwich), but the popular assumption that the Preemption Line was intended to be on that meridian seems to be a myth, since the District of Columbia had not been surveyed at the time of the 1786 treaty; in fact Benjamin Ellicott helped map and survey the District of Columbia in 1791–1792 and then re-surveyed the Preemption line in 1792 (see below).
The word "preemption" refers to the pre-emptive right that Massachusetts received to negotiate with the native sovereign tribes—pre-empting New York State, and also to the pre-emptive rights of the two state governments with respect to individuals, who were forbidden to negotiate directly with the sovereign tribes without first securing a patent from the respective legislature.
It is bounded on the east (New York portion) by:
the townships of Galen and Junius of the Central New York Military Tract north of Seneca Lake;
the Watkins and Flint Purchase south of the township of Reading in Schuyler County;
In between a narrow strip of land eastward to Seneca Lake purchased by James Watson.
It is bounded on the west (Massachusetts portion) by the Phelps and Gorham Purchase.
Time line
Time line for the history of the preemption line.
1628 – King Charles I of England grants land to the Massachusetts Bay Colony which includes what is now New York State.
1664 – King Charles II of England grants land to his brother, the Duke of York which also includes what is now New York State.
1783 Sep 3 – Treaty of Paris (1783) between US and England ending the American revolution.
1784 – Second treaty of Fort Stanwix. This was effectively a peace treaty between the US and the Haudenosaunee (Iroquois) tribes in which they ceded land to the west of New York state to the U.S., but not in what is now New York state, which amounted to some 6,000,000 acres.
1786 Dec 16 – Treaty of Hartford – Massachusetts and New York resolve their competing claims to the area of what is now New York State. New York State takes its present shape, and the land in New York west of the (unsurveyed) preemption line is considered part of New York state, but owned by the Haudenosaunee (Iroquois) tribes, with preemptive right of purchase by Massachusetts.
1788 Apr 1 – Massachusetts agrees to sell all of its preemptive rights to Oliver Phelps and Nathaniel Gorham of Massachusetts.
1788 Jul 8 – Phelps and Gorham purchase from the Haudenosaunee (Iroquois) tribes land amounting to some 2,600,000 acres.
1788 Jul 25 – Colonel Hugh Maxwell begins survey of the first (false) preemption line.
1792 Nov – Benjamin Ellicott begins survey of the second (true) preemption line.
1796 Apr 6 – The second preemption line is accepted by New York State.
The Old and New Preemption Lines
An interesting point is that there are two pre-emption lines: the Old and New (to the east of the Old); the area between is called the Gore (referring to a dressmaker's term for a wedge-shaped piece). This is because very soon after the original survey of 1788 it was suspected that this survey was in error, so a resurvey was commissioned in 1792. It showed that the first surveyors had used defective methods (or, as some allege but not proved fraudulent methods) so that the line, although beginning at the correct Pennsylvania boundary stone, was deflected about 2° west of north, hence the wedge shape (increasing in width to the north). It is not a simple error, however; once the survey was about two miles west of the correct line it then ran closer to true north. The original error was in favor of New York, which issued titles in the Gore; most notably, the current city of Geneva was incorrectly assigned. The new survey was accepted, as it was performed with a high-precision German transit by Benjamin Ellicott, who had just assisted in the initial survey of the District of Columbia (see Boundary Markers of the Original District of Columbia).
The magnitude of the error can be appreciated at Geneva: the true (new) line is at about the midpoint of Seneca Lake at the Seneca–Ontario County boundary, whereas the false (old) line is the present-day Pre-emption Road, which forms the western limits of the City of Geneva, about two miles west.
The Preemption Lines on the ground today
Both begin at the same point: the eighty-second milestone of the Pennsylvania–New York survey line, located on Widger Hill Road near Millerton, PA at .
Old Preemption Line
There is no trace of this line south of Schuyler County, probably because no settlement took place in this area prior to the resurvey. In Schuyler County it forms the west line of the town of Reading, for most of this length along Pre-emption Road. It continues as the short north-south portion of the boundary between Schuyler (west) and Yates Counties along this road, and then divides the Yates County towns of Barrington (west) and Starkey (east) to their tri-point with the town of Milo, where the road also ends. A portion of road through Milo Center to the Keuka Lake outlet is on the line. It is marked again in Ontario County by the Pre-emption Road through the towns of Geneva and Phelps; this road makes some local deviations from the line. The Pre-emption Road continues a short distance into Wayne County as far as the new Erie Canal; it is not marked farther north.
New Preemption Line
This line forms the boundary between Chemung (east) and Steuben (west) Counties as well as a small north-south portion of the border between Chemung (east) and Schuyler (west) Counties at the former's northwest corner near Beaver Dams. It then forms the line between the towns of Orange (west) and Montour (east) in Schuyler County; the only roads that follows the line in this section are at the very beginning north a few miles on Widger Hill Road, and a mile of Locust Lane in Sugar Hill State Forest.
There is an informational marker at the point where the line crosses NY 352 and the Keuka Outlet Trail. The line has no trace in Yates County; it runs north-south through Seneca Lake from a point north of Dresden.
It next appears at the north end of Seneca Lake and forms the boundary between Seneca (east) and Ontario (west) Counties to the tri-point with Wayne County; in this section it forms Pre-emption Road and most of West Town Line Road.
In Wayne County it continues north as the line between the towns of Lyons and Sodus (west) and Galen, Rose and Huron (east); small sections of roadway denote its path. The line then runs through and terminates in Lake Ontario's Sodus Bay.
References
External links
History of Tioga, Chemung, Tompkins and Schuyler Counties 1879 – Land Titles from Rootsweb
The Preemption Line Series of articles
Map of boundary stone 82 and the Chemung-Steuben county line
See also:
History of Massachusetts
Former regions and territories of the United States
History of New York (state)
|
```c++
/*********************************************************************************
* OKVIS - Open Keyframe-based Visual-Inertial SLAM
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of Autonomous Systems Lab / ETH Zurich nor the names of
* its contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Created on: Aug 30, 2013
* Author: Stefan Leutenegger (s.leutenegger@imperial.ac.uk)
*********************************************************************************/
/**
* @file PoseLocalParameterization.cpp
* @brief Source file for the PoseLocalParameterization class.
* @author Stefan Leutenegger
*/
#include <okvis/assert_macros.hpp>
#include <okvis/ceres/PoseLocalParameterization.hpp>
#include <okvis/kinematics/operators.hpp>
#include <okvis/kinematics/Transformation.hpp>
/// \brief okvis Main namespace of this package.
namespace okvis {
/// \brief ceres Namespace for ceres-related functionality implemented in okvis.
namespace ceres {
// Generalization of the addition operation,
// x_plus_delta = Plus(x, delta)
// with the condition that Plus(x, 0) = x.
bool PoseLocalParameterization::Plus(const double* x, const double* delta,
double* x_plus_delta) const {
return plus(x, delta, x_plus_delta);
}
// Generalization of the addition operation,
// x_plus_delta = Plus(x, delta)
// with the condition that Plus(x, 0) = x.
bool PoseLocalParameterization::plus(const double* x, const double* delta,
double* x_plus_delta) {
Eigen::Map<const Eigen::Matrix<double, 6, 1> > delta_(delta);
// transform to okvis::kinematics framework
okvis::kinematics::Transformation T(
Eigen::Vector3d(x[0], x[1], x[2]),
Eigen::Quaterniond(x[6], x[3], x[4], x[5]));
// call oplus operator in okvis::kinematis
T.oplus(delta_);
// copy back
const Eigen::Vector3d r = T.r();
x_plus_delta[0] = r[0];
x_plus_delta[1] = r[1];
x_plus_delta[2] = r[2];
const Eigen::Vector4d q = T.q().coeffs();
x_plus_delta[3] = q[0];
x_plus_delta[4] = q[1];
x_plus_delta[5] = q[2];
x_plus_delta[6] = q[3];
OKVIS_ASSERT_TRUE_DBG(std::runtime_error, T.q().norm()-1.0<1e-15, "damn.");
return true;
}
// Computes the minimal difference between a variable x and a perturbed variable x_plus_delta.
bool PoseLocalParameterization::Minus(const double* x,
const double* x_plus_delta,
double* delta) const {
return minus(x, x_plus_delta, delta);
}
// Computes the Jacobian from minimal space to naively overparameterised space as used by ceres.
bool PoseLocalParameterization::ComputeLiftJacobian(const double* x,
double* jacobian) const {
return liftJacobian(x, jacobian);
}
// Computes the minimal difference between a variable x and a perturbed variable x_plus_delta.
bool PoseLocalParameterization::minus(const double* x,
const double* x_plus_delta,
double* delta) {
delta[0] = x_plus_delta[0] - x[0];
delta[1] = x_plus_delta[1] - x[1];
delta[2] = x_plus_delta[2] - x[2];
const Eigen::Quaterniond q_plus_delta_(x_plus_delta[6], x_plus_delta[3],
x_plus_delta[4], x_plus_delta[5]);
const Eigen::Quaterniond q_(x[6], x[3], x[4], x[5]);
Eigen::Map<Eigen::Vector3d> delta_q_(&delta[3]);
delta_q_ = 2 * (q_plus_delta_ * q_.inverse()).coeffs().template head<3>();
return true;
}
// The jacobian of Plus(x, delta) w.r.t delta at delta = 0.
bool PoseLocalParameterization::plusJacobian(const double* x,
double* jacobian) {
Eigen::Map<Eigen::Matrix<double, 7, 6, Eigen::RowMajor> > Jp(jacobian);
okvis::kinematics::Transformation T(
Eigen::Vector3d(x[0], x[1], x[2]),
Eigen::Quaterniond(x[6], x[3], x[4], x[5]));
T.oplusJacobian(Jp);
return true;
}
// Computes the Jacobian from minimal space to naively overparameterised space as used by ceres.
bool PoseLocalParameterization::liftJacobian(const double* x,
double* jacobian) {
Eigen::Map<Eigen::Matrix<double, 6, 7, Eigen::RowMajor> > J_lift(jacobian);
const Eigen::Quaterniond q_inv(x[6], -x[3], -x[4], -x[5]);
J_lift.setZero();
J_lift.topLeftCorner<3, 3>().setIdentity();
Eigen::Matrix4d Qplus = okvis::kinematics::oplus(q_inv);
Eigen::Matrix<double, 3, 4> Jq_pinv;
Jq_pinv.bottomRightCorner<3, 1>().setZero();
Jq_pinv.topLeftCorner<3, 3>() = Eigen::Matrix3d::Identity() * 2.0;
J_lift.bottomRightCorner<3, 4>() = Jq_pinv * Qplus;
return true;
}
// The jacobian of Plus(x, delta) w.r.t delta at delta = 0.
bool PoseLocalParameterization::ComputeJacobian(const double* x,
double* jacobian) const {
return plusJacobian(x, jacobian);
}
bool PoseLocalParameterization::VerifyJacobianNumDiff(const double* x,
double* jacobian,
double* jacobianNumDiff) {
plusJacobian(x, jacobian);
Eigen::Map<Eigen::Matrix<double, 7, 6, Eigen::RowMajor> > Jp(jacobian);
Eigen::Map<Eigen::Matrix<double, 7, 6, Eigen::RowMajor> > Jpn(
jacobianNumDiff);
double dx = 1e-9;
Eigen::Matrix<double, 7, 1> xp;
Eigen::Matrix<double, 7, 1> xm;
for (size_t i = 0; i < 6; ++i) {
Eigen::Matrix<double, 6, 1> delta;
delta.setZero();
delta[i] = dx;
Plus(x, delta.data(), xp.data());
delta[i] = -dx;
Plus(x, delta.data(), xm.data());
Jpn.col(i) = (xp - xm) / (2 * dx);
}
if ((Jp - Jpn).norm() < 1e-6)
return true;
else
return false;
}
// Generalization of the addition operation,
// x_plus_delta = Plus(x, delta)
// with the condition that Plus(x, 0) = x.
bool PoseLocalParameterization3d::Plus(const double* x, const double* delta,
double* x_plus_delta) const {
Eigen::Matrix<double, 6, 1> delta_;
delta_.setZero();
delta_[3] = delta[0];
delta_[4] = delta[1];
delta_[5] = delta[2];
// transform to sm::kinematics framework
okvis::kinematics::Transformation T(
Eigen::Vector3d(x[0], x[1], x[2]),
Eigen::Quaterniond(x[6], x[3], x[4], x[5]));
// call oplus operator in sm::kinematis
T.oplus(delta_);
// copy back
x_plus_delta[0] = T.r()[0];
x_plus_delta[1] = T.r()[1];
x_plus_delta[2] = T.r()[2];
x_plus_delta[3] = T.q().coeffs()[0];
x_plus_delta[4] = T.q().coeffs()[1];
x_plus_delta[5] = T.q().coeffs()[2];
x_plus_delta[6] = T.q().coeffs()[3];
OKVIS_ASSERT_TRUE_DBG(std::runtime_error, T.q().norm() - 1.0 < 1e-15, "damn.");
return true;
}
// Computes the minimal difference between a variable x and a perturbed variable x_plus_delta.
bool PoseLocalParameterization3d::Minus(const double* x,
const double* x_plus_delta,
double* delta) const {
const Eigen::Quaterniond q_plus_delta_(x_plus_delta[6], x_plus_delta[3],
x_plus_delta[4], x_plus_delta[5]);
const Eigen::Quaterniond q_(x[6], x[3], x[4], x[5]);
Eigen::Vector3d delta_q_;
delta_q_ = 2 * (q_plus_delta_ * q_.inverse()).coeffs().template head<3>();
delta[0] = delta_q_[0];
delta[1] = delta_q_[1];
delta[2] = delta_q_[2];
return true;
}
// Computes the Jacobian from minimal space to naively overparameterised space as used by ceres.
bool PoseLocalParameterization3d::ComputeLiftJacobian(const double* x,
double* jacobian) const {
return liftJacobian(x, jacobian);
}
// The jacobian of Plus(x, delta) w.r.t delta at delta = 0.
bool PoseLocalParameterization3d::plusJacobian(const double* x,
double* jacobian) {
Eigen::Map<Eigen::Matrix<double, 7, 3, Eigen::RowMajor> > Jp(jacobian);
Jp.setZero();
// rotation: dq*q=qoplus(q)*dq=qoplus(q)*1/2*[I_3;0]*dalpha
Eigen::Matrix4d Qoplus = okvis::kinematics::oplus(
Eigen::Quaterniond(x[6], x[3], x[4], x[5]));
Eigen::Matrix<double, 4, 3> Jq;
Jq.bottomRightCorner<3, 3>().setZero();
Jq.topLeftCorner<3, 3>() = Eigen::Matrix3d::Identity() * 0.5;
Jp.bottomRightCorner<4, 3>() = Qoplus * Jq;
return true;
}
// Computes the Jacobian from minimal space to naively overparameterised space as used by ceres.
bool PoseLocalParameterization3d::liftJacobian(const double* x,
double* jacobian) {
Eigen::Map<Eigen::Matrix<double, 3, 7, Eigen::RowMajor> > J_lift(jacobian);
J_lift.setZero();
const Eigen::Quaterniond q_inv(x[6], -x[3], -x[4], -x[5]);
Eigen::Matrix4d Qplus = okvis::kinematics::oplus(q_inv);
Eigen::Matrix<double, 3, 4> Jq_pinv = Eigen::Matrix<double, 3, 4>::Zero();
Jq_pinv(0, 0) = 2.0;
Jq_pinv(1, 1) = 2.0;
Jq_pinv(2, 2) = 2.0;
J_lift.bottomRightCorner<3, 4>() = Jq_pinv * Qplus;
return true;
}
// The jacobian of Plus(x, delta) w.r.t delta at delta = 0.
bool PoseLocalParameterization3d::ComputeJacobian(const double* x,
double* jacobian) const {
return plusJacobian(x, jacobian);
}
// Generalization of the addition operation,
// x_plus_delta = Plus(x, delta)
// with the condition that Plus(x, 0) = x.
bool PoseLocalParameterization4d::Plus(const double* x, const double* delta,
double* x_plus_delta) const {
Eigen::Matrix<double, 6, 1> delta_;
delta_.setZero();
delta_[0] = delta[0];
delta_[1] = delta[1];
delta_[2] = delta[2];
delta_[5] = delta[3];
// transform to sm::kinematics framework
okvis::kinematics::Transformation T(
Eigen::Vector3d(x[0], x[1], x[2]),
Eigen::Quaterniond(x[6], x[3], x[4], x[5]));
// call oplus operator in sm::kinematis
T.oplus(delta_);
// copy back
x_plus_delta[0] = T.r()[0];
x_plus_delta[1] = T.r()[1];
x_plus_delta[2] = T.r()[2];
x_plus_delta[3] = T.q().coeffs()[0];
x_plus_delta[4] = T.q().coeffs()[1];
x_plus_delta[5] = T.q().coeffs()[2];
x_plus_delta[6] = T.q().coeffs()[3];
OKVIS_ASSERT_TRUE_DBG(std::runtime_error, T.q().norm() - 1.0 < 1e-15, "damn.");
return true;
}
// Computes the minimal difference between a variable x and a perturbed variable x_plus_delta.
bool PoseLocalParameterization4d::Minus(const double* x,
const double* x_plus_delta,
double* delta) const {
delta[0] = x_plus_delta[0] - x[0];
delta[1] = x_plus_delta[1] - x[1];
delta[2] = x_plus_delta[2] - x[2];
const Eigen::Quaterniond q_plus_delta_(x_plus_delta[6], x_plus_delta[3],
x_plus_delta[4], x_plus_delta[5]);
const Eigen::Quaterniond q_(x[6], x[3], x[4], x[5]);
delta[3] = 2 * (q_plus_delta_ * q_.inverse()).coeffs()[2];
return true;
}
// Computes the Jacobian from minimal space to naively overparameterised space as used by ceres.
bool PoseLocalParameterization4d::ComputeLiftJacobian(const double* x,
double* jacobian) const {
return liftJacobian(x, jacobian);
}
// The jacobian of Plus(x, delta) w.r.t delta at delta = 0.
bool PoseLocalParameterization4d::plusJacobian(const double* x,
double* jacobian) {
Eigen::Map<Eigen::Matrix<double, 7, 4, Eigen::RowMajor> > Jp(jacobian);
Eigen::Matrix<double, 7, 6, Eigen::RowMajor> Jp_full;
okvis::kinematics::Transformation T(
Eigen::Vector3d(x[0], x[1], x[2]),
Eigen::Quaterniond(x[6], x[3], x[4], x[5]));
T.oplusJacobian(Jp_full);
Jp.topLeftCorner<7,3>()=Jp_full.topLeftCorner<7,3>();
Jp.bottomRightCorner<7,1>()=Jp_full.bottomRightCorner<7,1>();
return true;
}
// Computes the Jacobian from minimal space to naively overparameterised space as used by ceres.
bool PoseLocalParameterization4d::liftJacobian(const double* x,
double* jacobian) {
Eigen::Map<Eigen::Matrix<double, 4, 7, Eigen::RowMajor> > J_lift(jacobian);
const Eigen::Quaterniond q_inv(x[6], -x[3], -x[4], -x[5]);
J_lift.setZero();
J_lift.topLeftCorner<3, 3>().setIdentity();
Eigen::Matrix4d Qplus = okvis::kinematics::oplus(q_inv);
Eigen::Matrix<double, 3, 4> Jq_pinv;
Jq_pinv.bottomRightCorner<3, 1>().setZero();
Jq_pinv.topLeftCorner<3, 3>() = Eigen::Matrix3d::Identity() * 2.0;
J_lift.bottomRightCorner<1, 4>() = (Jq_pinv * Qplus).bottomRightCorner<1, 4>();
return true;
}
// The jacobian of Plus(x, delta) w.r.t delta at delta = 0.
bool PoseLocalParameterization4d::ComputeJacobian(const double* x,
double* jacobian) const {
return plusJacobian(x, jacobian);
}
// Generalization of the addition operation,
// x_plus_delta = Plus(x, delta)
// with the condition that Plus(x, 0) = x.
bool PoseLocalParameterization2d::Plus(const double* x, const double* delta,
double* x_plus_delta) const {
Eigen::Matrix<double, 6, 1> delta_;
delta_.setZero();
delta_[3] = delta[0];
delta_[4] = delta[1];
// transform to okvis::kinematics framework
okvis::kinematics::Transformation T(
Eigen::Vector3d(x[0], x[1], x[2]),
Eigen::Quaterniond(x[6], x[3], x[4], x[5]));
// call oplus operator in okvis::kinematis
T.oplus(delta_);
// copy back
x_plus_delta[0] = T.r()[0];
x_plus_delta[1] = T.r()[1];
x_plus_delta[2] = T.r()[2];
x_plus_delta[3] = T.q().coeffs()[0];
x_plus_delta[4] = T.q().coeffs()[1];
x_plus_delta[5] = T.q().coeffs()[2];
x_plus_delta[6] = T.q().coeffs()[3];
OKVIS_ASSERT_TRUE_DBG(std::runtime_error, T.q().norm() - 1.0 < 1e-15, "damn.");
return true;
}
// Computes the minimal difference between a variable x and a perturbed variable x_plus_delta.
bool PoseLocalParameterization2d::Minus(const double* x,
const double* x_plus_delta,
double* delta) const {
const Eigen::Quaterniond q_plus_delta_(x_plus_delta[6], x_plus_delta[3],
x_plus_delta[4], x_plus_delta[5]);
const Eigen::Quaterniond q_(x[6], x[3], x[4], x[5]);
Eigen::Vector3d delta_q_;
delta_q_ = 2 * (q_plus_delta_ * q_.inverse()).coeffs().template head<3>();
delta[0] = delta_q_[0];
delta[1] = delta_q_[1];
return true;
}
// Computes the Jacobian from minimal space to naively overparameterised space as used by ceres.
bool PoseLocalParameterization2d::ComputeLiftJacobian(const double* x,
double* jacobian) const {
return liftJacobian(x, jacobian);
}
// The jacobian of Plus(x, delta) w.r.t delta at delta = 0.
bool PoseLocalParameterization2d::plusJacobian(const double* x,
double* jacobian) {
Eigen::Map<Eigen::Matrix<double, 7, 2, Eigen::RowMajor> > Jp(jacobian);
Jp.setZero();
// rotation: dq*q=qoplus(q)*dq=qoplus(q)*1/2*[I_3;0]*dalpha
Eigen::Matrix4d Qoplus = okvis::kinematics::oplus(
Eigen::Quaterniond(x[6], x[3], x[4], x[5]));
Eigen::Matrix<double, 4, 2> Jq;
Jq.bottomRightCorner<2, 2>().setZero();
Jq.topLeftCorner<2, 2>() = Eigen::Matrix2d::Identity() * 0.5;
Jp.bottomRightCorner<4, 2>() = Qoplus * Jq;
return true;
}
// Computes the Jacobian from minimal space to naively overparameterised space as used by ceres.
bool PoseLocalParameterization2d::liftJacobian(const double* x,
double* jacobian) {
Eigen::Map<Eigen::Matrix<double, 2, 7, Eigen::RowMajor> > J_lift(jacobian);
J_lift.setZero();
const Eigen::Quaterniond q_inv(x[6], -x[3], -x[4], -x[5]);
Eigen::Matrix4d Qplus = okvis::kinematics::oplus(q_inv);
Eigen::Matrix<double, 2, 4> Jq_pinv = Eigen::Matrix<double, 2, 4>::Zero();
Jq_pinv(0, 0) = 2.0;
Jq_pinv(1, 1) = 2.0;
J_lift.bottomRightCorner<2, 4>() = Jq_pinv * Qplus;
return true;
}
// The jacobian of Plus(x, delta) w.r.t delta at delta = 0.
bool PoseLocalParameterization2d::ComputeJacobian(const double* x,
double* jacobian) const {
return plusJacobian(x, jacobian);
}
} // namespace ceres
} // namespace okvis
```
|
Irene Kelley is an American country and bluegrass musician. As a songwriter, she has written for Ricky Skaggs, Alan Jackson, Loretta Lynn, and the Osborne Brothers.
Early life
Kelley is originally from Pennsylvania and in high school sang in a Led Zeppelin cover band. She was asked to leave the group after suggesting the band cover songs from Dolly Parton.
Career
Kelley moved to Nashville, Tennessee in the early 1980s. This was after visiting on her honeymoon in 1983 and discovering the first gathering of the International Bluegrass Music Association. Kelley co-wrote the Ricky Skaggs and Sharon White song "Love Can't Ever Get Better Than This" with Nancy Montgomery. The song peaked at number ten on the Billboard Hot Country Singles chart in 1987 and was awarded Duet of the Year at the Country Music Association Awards that same year. Kelley signed to MCA Records in the late 1980s.
Discography
Albums
Singles
Music videos
References
Living people
American bluegrass musicians
Year of birth missing (living people)
Place of birth missing (living people)
Country musicians from Pennsylvania
|
```javascript
// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: path_to_url
(function(mod) {
if (typeof exports == "object" && typeof module == "object") // CommonJS
mod(require("../../lib/codemirror"));
else if (typeof define == "function" && define.amd) // AMD
define(["../../lib/codemirror"], mod);
else // Plain browser env
mod(CodeMirror);
})(function(CodeMirror) {
"use strict";
var GUTTER_ID = "CodeMirror-lint-markers";
function showTooltip(e, content) {
var tt = document.createElement("div");
tt.className = "CodeMirror-lint-tooltip";
tt.appendChild(content.cloneNode(true));
document.body.appendChild(tt);
function position(e) {
if (!tt.parentNode) return CodeMirror.off(document, "mousemove", position);
tt.style.top = Math.max(0, e.clientY - tt.offsetHeight - 5) + "px";
tt.style.left = (e.clientX + 5) + "px";
}
CodeMirror.on(document, "mousemove", position);
position(e);
if (tt.style.opacity != null) tt.style.opacity = 1;
return tt;
}
function rm(elt) {
if (elt.parentNode) elt.parentNode.removeChild(elt);
}
function hideTooltip(tt) {
if (!tt.parentNode) return;
if (tt.style.opacity == null) rm(tt);
tt.style.opacity = 0;
setTimeout(function() { rm(tt); }, 600);
}
function showTooltipFor(e, content, node) {
var tooltip = showTooltip(e, content);
function hide() {
CodeMirror.off(node, "mouseout", hide);
if (tooltip) { hideTooltip(tooltip); tooltip = null; }
}
var poll = setInterval(function() {
if (tooltip) for (var n = node;; n = n.parentNode) {
if (n && n.nodeType == 11) n = n.host;
if (n == document.body) return;
if (!n) { hide(); break; }
}
if (!tooltip) return clearInterval(poll);
}, 400);
CodeMirror.on(node, "mouseout", hide);
}
function LintState(cm, options, hasGutter) {
this.marked = [];
this.options = options;
this.timeout = null;
this.hasGutter = hasGutter;
this.onMouseOver = function(e) { onMouseOver(cm, e); };
}
function parseOptions(cm, options) {
if (options instanceof Function) return {getAnnotations: options};
if (!options || options === true) options = {};
if (!options.getAnnotations) options.getAnnotations = cm.getHelper(CodeMirror.Pos(0, 0), "lint");
if (!options.getAnnotations) throw new Error("Required option 'getAnnotations' missing (lint addon)");
return options;
}
function clearMarks(cm) {
var state = cm.state.lint;
if (state.hasGutter) cm.clearGutter(GUTTER_ID);
for (var i = 0; i < state.marked.length; ++i)
state.marked[i].clear();
state.marked.length = 0;
}
function makeMarker(labels, severity, multiple, tooltips) {
var marker = document.createElement("div"), inner = marker;
marker.className = "CodeMirror-lint-marker-" + severity;
if (multiple) {
inner = marker.appendChild(document.createElement("div"));
inner.className = "CodeMirror-lint-marker-multiple";
}
if (tooltips != false) CodeMirror.on(inner, "mouseover", function(e) {
showTooltipFor(e, labels, inner);
});
return marker;
}
function getMaxSeverity(a, b) {
if (a == "error") return a;
else return b;
}
function groupByLine(annotations) {
var lines = [];
for (var i = 0; i < annotations.length; ++i) {
var ann = annotations[i], line = ann.from.line;
(lines[line] || (lines[line] = [])).push(ann);
}
return lines;
}
function annotationTooltip(ann) {
var severity = ann.severity;
if (!severity) severity = "error";
var tip = document.createElement("div");
tip.className = "CodeMirror-lint-message-" + severity;
tip.appendChild(document.createTextNode(ann.message));
return tip;
}
function startLinting(cm) {
var state = cm.state.lint, options = state.options;
var passOptions = options.options || options; // Support deprecated passing of `options` property in options
if (options.async || options.getAnnotations.async)
options.getAnnotations(cm.getValue(), updateLinting, passOptions, cm);
else
updateLinting(cm, options.getAnnotations(cm.getValue(), passOptions, cm));
}
function updateLinting(cm, annotationsNotSorted) {
clearMarks(cm);
var state = cm.state.lint, options = state.options;
var annotations = groupByLine(annotationsNotSorted);
for (var line = 0; line < annotations.length; ++line) {
var anns = annotations[line];
if (!anns) continue;
var maxSeverity = null;
var tipLabel = state.hasGutter && document.createDocumentFragment();
for (var i = 0; i < anns.length; ++i) {
var ann = anns[i];
var severity = ann.severity;
if (!severity) severity = "error";
maxSeverity = getMaxSeverity(maxSeverity, severity);
if (options.formatAnnotation) ann = options.formatAnnotation(ann);
if (state.hasGutter) tipLabel.appendChild(annotationTooltip(ann));
if (ann.to) state.marked.push(cm.markText(ann.from, ann.to, {
className: "CodeMirror-lint-mark-" + severity,
__annotation: ann
}));
}
if (state.hasGutter)
cm.setGutterMarker(line, GUTTER_ID, makeMarker(tipLabel, maxSeverity, anns.length > 1,
state.options.tooltips));
}
if (options.onUpdateLinting) options.onUpdateLinting(annotationsNotSorted, annotations, cm);
}
function onChange(cm) {
var state = cm.state.lint;
clearTimeout(state.timeout);
state.timeout = setTimeout(function(){startLinting(cm);}, state.options.delay || 500);
}
function popupSpanTooltip(ann, e) {
var target = e.target || e.srcElement;
showTooltipFor(e, annotationTooltip(ann), target);
}
function onMouseOver(cm, e) {
var target = e.target || e.srcElement;
if (!/\bCodeMirror-lint-mark-/.test(target.className)) return;
var box = target.getBoundingClientRect(), x = (box.left + box.right) / 2, y = (box.top + box.bottom) / 2;
var spans = cm.findMarksAt(cm.coordsChar({left: x, top: y}, "client"));
for (var i = 0; i < spans.length; ++i) {
var ann = spans[i].__annotation;
if (ann) return popupSpanTooltip(ann, e);
}
}
CodeMirror.defineOption("lint", false, function(cm, val, old) {
if (old && old != CodeMirror.Init) {
clearMarks(cm);
cm.off("change", onChange);
CodeMirror.off(cm.getWrapperElement(), "mouseover", cm.state.lint.onMouseOver);
delete cm.state.lint;
}
if (val) {
var gutters = cm.getOption("gutters"), hasLintGutter = false;
for (var i = 0; i < gutters.length; ++i) if (gutters[i] == GUTTER_ID) hasLintGutter = true;
var state = cm.state.lint = new LintState(cm, parseOptions(cm, val), hasLintGutter);
cm.on("change", onChange);
if (state.options.tooltips != false)
CodeMirror.on(cm.getWrapperElement(), "mouseover", state.onMouseOver);
startLinting(cm);
}
});
});
```
|
Good Timin' may refer to:
"Good Timin'" (The Beach Boys song), a song by The Beach Boys
"Good Timin'" (Jimmy Jones song), a UK #1 by Jimmy Jones
|
Moinul Hossain Chowdhury, Bir Bikrom (died 10 October 2010) was a Bangladesh Army officer who served as the adjutant general of Bangladesh army and former advisor of the caretaker government.
Military career
Moinul Hossain Chowdhury fought in the Bangladesh Liberation war. He was awarded Bir Bikrom for his role in the war. He was adjutant general of Bangladesh army in 1975 when the president of Bangladesh Sheikh Mujib was killed in a military coup. Major Rashid one of the coup plotters tried to recruit him into planning the coup. He was appointed to the post of chief advisor of the Muktijoddha Sangsad by president Ziaur Rahman but was replaced by President Ershad. When President Ziaur Rahman was assassinated, it was his job to investigate the coup but he was sidelined by then Army chief General Hussain Muhammad Ershad. As a result, he did not sign order of inquiry which he was supposed to; Ershad ended up signing it. He died on 10 October 2010.
Post-military career
He was a diplomat and served as ambassador of Bangladesh to a number of countries. He served as an advisor in the caretaker Government of former Chief Justice Latifur Rahman.
Bibliography
He wrote Silent Witness of a General about his time in Bangladesh Army along with several newspaper articles, both in English and Bangla.
References
Year of birth missing
2010 deaths
Pakistan Military Academy alumni
Bangladesh Army generals
Advisers of caretaker governments of Bangladesh
Recipients of the Bir Bikrom
Mukti Bahini personnel
|
```objective-c
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_INTL_SUPPORT
#error Internationalization is expected to be enabled.
#endif // V8_INTL_SUPPORT
#ifndef V8_OBJECTS_JS_NUMBER_FORMAT_INL_H_
#define V8_OBJECTS_JS_NUMBER_FORMAT_INL_H_
#include "src/objects/js-number-format.h"
#include "src/objects/objects-inl.h"
// Has to be the last include (doesn't have include guards):
#include "src/objects/object-macros.h"
namespace v8 {
namespace internal {
TQ_OBJECT_CONSTRUCTORS_IMPL(JSNumberFormat)
ACCESSORS(JSNumberFormat, icu_number_formatter,
Managed<icu::number::LocalizedNumberFormatter>,
kIcuNumberFormatterOffset)
} // namespace internal
} // namespace v8
#include "src/objects/object-macros-undef.h"
#endif // V8_OBJECTS_JS_NUMBER_FORMAT_INL_H_
```
|
```viml
call ale#Set('yaml_gitlablint_executable', 'gll')
call ale#Set('yaml_gitlablint_options', '')
function! ale_linters#yaml#gitlablint#GetCommand(buffer) abort
return '%e' . ale#Pad(ale#Var(a:buffer, 'yaml_gitlablint_options'))
\ . ' -p %t'
endfunction
function! ale_linters#yaml#gitlablint#Handle(buffer, lines) abort
" Matches patterns line the following:
" (<unknown>): mapping values are not allowed in this context at line 68 column 8
" jobs:build:dev config contains unknown keys: ony
let l:pattern = '^\(.*\) at line \(\d\+\) column \(\d\+\)$'
let l:output = []
for l:line in a:lines
let l:match = matchlist(l:line, l:pattern)
if !empty(l:match)
let l:item = {
\ 'lnum': l:match[2] + 0,
\ 'col': l:match[3] + 0,
\ 'text': l:match[1],
\ 'type': 'E',
\}
call add(l:output, l:item)
else
if l:line isnot# 'GitLab CI configuration is invalid'
let l:item = {
\ 'lnum': 0,
\ 'col': 0,
\ 'text': l:line,
\ 'type': 'E',
\}
call add(l:output, l:item)
endif
endif
endfor
return l:output
endfunction
call ale#linter#Define('yaml', {
\ 'name': 'gitlablint',
\ 'executable': {b -> ale#Var(b, 'yaml_gitlablint_executable')},
\ 'command': function('ale_linters#yaml#gitlablint#GetCommand'),
\ 'callback': 'ale_linters#yaml#gitlablint#Handle',
\ 'output_stream': 'stderr',
\})
```
|
Busy Bodies is a 1933 short comedy film starring Laurel and Hardy.
Plot
Stan and Ollie are in high spirits as they drive in an old Model T to their new jobs at the sawmill. Laurel turns on the car radio (at the time a luxury item in newer cars, not expected in an old jalopy); the 'radio' is revealed to be a wind-up phonograph stashed under the car hood. Arriving at the sawmill, a slapstick sequence has them repeatedly walking into planks of wood. Starting work, Stan soon traps Ollie's hands in a window frame. After freeing him, they trick a shop worker (Charlie Hall) into smoking despite a "No Smoking" sign. Stan then tears a strip off Ollie's pants with a plane and in the resulting 'tit for tat' dips a paintbrush in glue and sticks it onto Ollie's chin. Finding it is not possible to pull it off he prepares like a barber and shaves it with a plane. Ollie then gets propelled through a ventilator duct and out of an attic vent port.
Stan climbs a ladder to help him out. A barrel of shellac is kicked down the ventilator shaft and knocks Ollie out of the vent port: the ladder topples over with them both on it. Down below, two men see the ladder falling towards them. One falls into some whitewash while the other hides in a shed, which proves to be a bad idea when the duo crash onto the shed, demolishing it. As Laurel helps Hardy out of the wreckage, there is a knocking from beneath the door. The man they help out proves to be their foreman, who was the one who sought cover in the shed. They beat a hasty retreat. The foreman would have run after them, but he was crowned by the barrel coming out of the vent port. Attempting to flee, their car gets sawed in two lengthwise by a large band saw whilst they remain seated in it. The two fall out of the collapsing wreckage. Laurel finds the phonograph still intact and plays a record. Hardy is singularly unimpressed by music now, and chases Laurel.
Cast
Stan Laurel as Stan
Oliver Hardy as Ollie
Dick Gilbert as Shoveler
Charlie Hall as Shop Worker
Tiny Sandford as Shop Foreman
Jack Hill as Shop Worker
Charley Young as Shop Worker
References
External links
1933 films
1933 comedy films
American black-and-white films
1930s English-language films
Films directed by Lloyd French
Laurel and Hardy (film series)
1933 short films
American comedy short films
1930s American films
|
```go
// Code generated by counterfeiter. DO NOT EDIT.
package mocks
import (
"sync"
"github.com/hyperledger/fabric/common/ledger"
)
type ResultsIterator struct {
CloseStub func()
closeMutex sync.RWMutex
closeArgsForCall []struct {
}
NextStub func() (ledger.QueryResult, error)
nextMutex sync.RWMutex
nextArgsForCall []struct {
}
nextReturns struct {
result1 ledger.QueryResult
result2 error
}
nextReturnsOnCall map[int]struct {
result1 ledger.QueryResult
result2 error
}
invocations map[string][][]interface{}
invocationsMutex sync.RWMutex
}
func (fake *ResultsIterator) Close() {
fake.closeMutex.Lock()
fake.closeArgsForCall = append(fake.closeArgsForCall, struct {
}{})
stub := fake.CloseStub
fake.recordInvocation("Close", []interface{}{})
fake.closeMutex.Unlock()
if stub != nil {
fake.CloseStub()
}
}
func (fake *ResultsIterator) CloseCallCount() int {
fake.closeMutex.RLock()
defer fake.closeMutex.RUnlock()
return len(fake.closeArgsForCall)
}
func (fake *ResultsIterator) CloseCalls(stub func()) {
fake.closeMutex.Lock()
defer fake.closeMutex.Unlock()
fake.CloseStub = stub
}
func (fake *ResultsIterator) Next() (ledger.QueryResult, error) {
fake.nextMutex.Lock()
ret, specificReturn := fake.nextReturnsOnCall[len(fake.nextArgsForCall)]
fake.nextArgsForCall = append(fake.nextArgsForCall, struct {
}{})
stub := fake.NextStub
fakeReturns := fake.nextReturns
fake.recordInvocation("Next", []interface{}{})
fake.nextMutex.Unlock()
if stub != nil {
return stub()
}
if specificReturn {
return ret.result1, ret.result2
}
return fakeReturns.result1, fakeReturns.result2
}
func (fake *ResultsIterator) NextCallCount() int {
fake.nextMutex.RLock()
defer fake.nextMutex.RUnlock()
return len(fake.nextArgsForCall)
}
func (fake *ResultsIterator) NextCalls(stub func() (ledger.QueryResult, error)) {
fake.nextMutex.Lock()
defer fake.nextMutex.Unlock()
fake.NextStub = stub
}
func (fake *ResultsIterator) NextReturns(result1 ledger.QueryResult, result2 error) {
fake.nextMutex.Lock()
defer fake.nextMutex.Unlock()
fake.NextStub = nil
fake.nextReturns = struct {
result1 ledger.QueryResult
result2 error
}{result1, result2}
}
func (fake *ResultsIterator) NextReturnsOnCall(i int, result1 ledger.QueryResult, result2 error) {
fake.nextMutex.Lock()
defer fake.nextMutex.Unlock()
fake.NextStub = nil
if fake.nextReturnsOnCall == nil {
fake.nextReturnsOnCall = make(map[int]struct {
result1 ledger.QueryResult
result2 error
})
}
fake.nextReturnsOnCall[i] = struct {
result1 ledger.QueryResult
result2 error
}{result1, result2}
}
func (fake *ResultsIterator) Invocations() map[string][][]interface{} {
fake.invocationsMutex.RLock()
defer fake.invocationsMutex.RUnlock()
fake.closeMutex.RLock()
defer fake.closeMutex.RUnlock()
fake.nextMutex.RLock()
defer fake.nextMutex.RUnlock()
copiedInvocations := map[string][][]interface{}{}
for key, value := range fake.invocations {
copiedInvocations[key] = value
}
return copiedInvocations
}
func (fake *ResultsIterator) recordInvocation(key string, args []interface{}) {
fake.invocationsMutex.Lock()
defer fake.invocationsMutex.Unlock()
if fake.invocations == nil {
fake.invocations = map[string][][]interface{}{}
}
if fake.invocations[key] == nil {
fake.invocations[key] = [][]interface{}{}
}
fake.invocations[key] = append(fake.invocations[key], args)
}
```
|
```html
{{ $pages := .CurrentSection.Pages }}
{{ with site.Params.language_alternatives }}
{{ range . }}
{{ with (where $.CurrentSection.Translations ".Lang" . ) }}
{{ $p := index . 0 }}
{{ $pages = $pages | lang.Merge $p.Pages }}
{{ end }}
{{ end }}
{{ end }}
<div class="panel-group" id="blog-archive">
{{ range $i, $e := $pages.GroupByPublishDate "2006" }}
<div class="panel panel-default">
<div class="panel-heading">
<h4 class="panel-title">
<a data-toggle="collapse" data-parent="#blog-archive" href="#collapse-{{ .Key }}">
{{ .Key }}</a>
</h4>
</div>
<div id="collapse-{{ .Key }}" class="panel-collapse collapse{{ if eq $i 0 }} show{{ end }}">
<div class="panel-body">
<ul class="list-group">
{{ range .Pages }}
{{ $isForeignLanguage := (ne .Lang $.Lang)}}
<li class="list-group-item"><a href="{{ .Permalink }}"{{ if $isForeignLanguage }} target="_blank" {{ end }}>{{ .LinkTitle }}</a> <span class="date">{{ .PublishDate.Format "Jan 2" }}</span>{{ if $isForeignLanguage }} <small>({{ .Lang | upper }})</small>{{ end }}</li>
{{ end }}
</ul>
</div>
</div>
</div>
{{ end }}
</div>
```
|
```javascript
// Flags: --expose-internals
'use strict';
const common = require('../common');
const assert = require('assert');
const JSStreamWrap = require('internal/js_stream_socket');
const { Duplex } = require('stream');
process.once('uncaughtException', common.mustCall((err) => {
assert.strictEqual(err.message, 'exception!');
}));
const socket = new JSStreamWrap(new Duplex({
read: common.mustNotCall(),
write: common.mustCall((buffer, data, cb) => {
throw new Error('exception!');
})
}));
assert.throws(() => socket.end('foo'), /Error: write EPROTO/);
```
|
```python
# -*- coding: utf-8 -*-
"""Generic feature selection mixin"""
# Authors: G. Varoquaux, A. Gramfort, L. Buitinck, J. Nothman
from abc import ABCMeta, abstractmethod
from warnings import warn
import numpy as np
from scipy.sparse import issparse, csc_matrix
from ..base import TransformerMixin
from ..utils import check_array, safe_mask
from ..externals import six
class SelectorMixin(six.with_metaclass(ABCMeta, TransformerMixin)):
"""
Tranformer mixin that performs feature selection given a support mask
This mixin provides a feature selector implementation with `transform` and
`inverse_transform` functionality given an implementation of
`_get_support_mask`.
"""
def get_support(self, indices=False):
"""
Get a mask, or integer index, of the features selected
Parameters
----------
indices : boolean (default False)
If True, the return value will be an array of integers, rather
than a boolean mask.
Returns
-------
support : array
An index that selects the retained features from a feature vector.
If `indices` is False, this is a boolean array of shape
[# input features], in which an element is True iff its
corresponding feature is selected for retention. If `indices` is
True, this is an integer array of shape [# output features] whose
values are indices into the input feature vector.
"""
mask = self._get_support_mask()
return mask if not indices else np.where(mask)[0]
@abstractmethod
def _get_support_mask(self):
"""
Get the boolean mask indicating which features are selected
Returns
-------
support : boolean array of shape [# input features]
An element is True iff its corresponding feature is selected for
retention.
"""
def transform(self, X):
"""Reduce X to the selected features.
Parameters
----------
X : array of shape [n_samples, n_features]
The input samples.
Returns
-------
X_r : array of shape [n_samples, n_selected_features]
The input samples with only the selected features.
"""
X = check_array(X, accept_sparse='csr')
mask = self.get_support()
if not mask.any():
warn("No features were selected: either the data is"
" too noisy or the selection test too strict.",
UserWarning)
return np.empty(0).reshape((X.shape[0], 0))
if len(mask) != X.shape[1]:
raise ValueError("X has a different shape than during fitting.")
return X[:, safe_mask(X, mask)]
def inverse_transform(self, X):
"""
Reverse the transformation operation
Parameters
----------
X : array of shape [n_samples, n_selected_features]
The input samples.
Returns
-------
X_r : array of shape [n_samples, n_original_features]
`X` with columns of zeros inserted where features would have
been removed by `transform`.
"""
if issparse(X):
X = X.tocsc()
# insert additional entries in indptr:
# e.g. if transform changed indptr from [0 2 6 7] to [0 2 3]
# col_nonzeros here will be [2 0 1] so indptr becomes [0 2 2 3]
it = self.inverse_transform(np.diff(X.indptr).reshape(1, -1))
col_nonzeros = it.ravel()
indptr = np.concatenate([[0], np.cumsum(col_nonzeros)])
Xt = csc_matrix((X.data, X.indices, indptr),
shape=(X.shape[0], len(indptr) - 1), dtype=X.dtype)
return Xt
support = self.get_support()
X = check_array(X)
if support.sum() != X.shape[1]:
raise ValueError("X has a different shape than during fitting.")
if X.ndim == 1:
X = X[None, :]
Xt = np.zeros((X.shape[0], support.size), dtype=X.dtype)
Xt[:, support] = X
return Xt
```
|
Włynkowo railway station is a railway station located in Włynkowo, Pomeranian Voivodeship.
Railway stations in Pomeranian Voivodeship
|
```c++
#include "frtconfigresponse.h"
#include <vespa/fnet/frt/rpcrequest.h>
namespace config {
FRTConfigResponse::FRTConfigResponse(FRT_RPCRequest * request)
: _request(request),
_responseState(EMPTY),
_returnValues(_request->GetReturn())
{
_request->internal_addref();
}
FRTConfigResponse::~FRTConfigResponse()
{
_request->internal_subref();
}
bool
FRTConfigResponse::validateResponse()
{
if (_request->IsError())
_responseState = ERROR;
if (_request->GetReturn()->GetNumValues() == 0)
_responseState = EMPTY;
if (_request->CheckReturnTypes(getResponseTypes().c_str())) {
_returnValues = _request->GetReturn();
_responseState = OK;
}
return (_responseState == OK);
}
bool
FRTConfigResponse::hasValidResponse() const
{
return (_responseState == OK);
}
std::string FRTConfigResponse::errorMessage() const { return _request->GetErrorMessage(); }
int FRTConfigResponse::errorCode() const { return _request->GetErrorCode(); }
bool FRTConfigResponse::isError() const { return _request->IsError(); }
} // namespace config
```
|
```java
/**
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package io.pravega.test.integration.selftest;
import com.google.common.base.Preconditions;
import io.pravega.common.Exceptions;
import io.pravega.common.function.Callbacks;
import java.util.concurrent.CompletableFuture;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import lombok.Getter;
import lombok.Setter;
/**
* Represents an Operation for a Producer
*/
class ProducerOperation<T extends ProducerUpdate> {
//region Members
@Getter
private final ProducerOperationType type;
@Getter
private final String target;
@Getter
@Setter
private T update;
@Getter
@Setter
private Object result;
@Getter
@Setter
private int length;
@Getter
@Setter
private CompletableFuture<Void> waitOn;
@Setter
private Consumer<ProducerOperation<T>> completionCallback;
@Setter
private BiConsumer<ProducerOperation<T>, Throwable> failureCallback;
@Getter
private long elapsedMillis = 0;
//endregion
//region Constructor
/**
* Creates a new instance of the ProducerOperation class.
*
* @param type The type of the operation.
* @param target The target (Segment name) of the operation.
*/
ProducerOperation(ProducerOperationType type, String target) {
Preconditions.checkNotNull(type, "type");
Exceptions.checkNotNullOrEmpty(target, "target");
this.type = type;
this.target = target;
}
//endregion
//region Completion
/**
* Indicates that this ProducerOperation completed successfully. Invokes any associated success callbacks that are
* registered with it.
*
* @param elapsedMillis The elapsed time, in milliseconds, for this operation.
*/
void completed(long elapsedMillis) {
this.elapsedMillis = elapsedMillis;
if (this.update != null) {
this.update.release();
}
Consumer<ProducerOperation<T>> callback = this.completionCallback;
if (callback != null) {
Callbacks.invokeSafely(callback, this, null);
}
}
/**
* Indicates that this ProducerOperation failed to complete. Invokes any associated failure callbacks that are registered
* with it.
*/
void failed(Throwable ex) {
if (this.update != null) {
this.update.release();
}
BiConsumer<ProducerOperation<T>, Throwable> callback = this.failureCallback;
if (callback != null) {
Callbacks.invokeSafely(callback, this, ex, null);
}
}
//endregion
@Override
public String toString() {
return String.format("%s: %s", this.type, this.target);
}
}
```
|
```java
/*
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package org.apache.beam.runners.samza;
import org.apache.beam.runners.jobsubmission.JobServerDriver;
import org.apache.beam.sdk.fn.server.ServerFactory;
import org.apache.beam.sdk.io.FileSystems;
import org.apache.beam.sdk.options.PipelineOptions;
import org.apache.beam.sdk.options.PipelineOptionsFactory;
import org.kohsuke.args4j.CmdLineException;
import org.kohsuke.args4j.CmdLineParser;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/** Driver program that starts a job server for the Samza runner. */
public class SamzaJobServerDriver extends JobServerDriver {
private static final Logger LOG = LoggerFactory.getLogger(SamzaJobServerDriver.class);
/** Samza runner-specific Configuration for the jobServer. */
public static class SamzaServerConfiguration extends ServerConfiguration {}
public static void main(String[] args) {
// TODO: Expose the fileSystem related options.
PipelineOptions options = PipelineOptionsFactory.create();
// Register standard file systems.
FileSystems.setDefaultPipelineOptions(options);
fromParams(args).run();
}
private static SamzaJobServerDriver fromParams(String[] args) {
return fromConfig(parseArgs(args));
}
private static void printUsage(CmdLineParser parser) {
System.err.printf("Usage: java %s arguments...%n", SamzaJobServerDriver.class.getSimpleName());
parser.printUsage(System.err);
System.err.println();
}
private static SamzaJobServerDriver fromConfig(SamzaServerConfiguration configuration) {
return create(
configuration,
createJobServerFactory(configuration),
createArtifactServerFactory(configuration));
}
public static SamzaServerConfiguration parseArgs(String[] args) {
SamzaServerConfiguration configuration = new SamzaServerConfiguration();
CmdLineParser parser = new CmdLineParser(configuration);
try {
parser.parseArgument(args);
} catch (CmdLineException e) {
LOG.error("Unable to parse command line arguments.", e);
printUsage(parser);
throw new IllegalArgumentException("Unable to parse command line arguments.", e);
}
return configuration;
}
private static SamzaJobServerDriver create(
SamzaServerConfiguration configuration,
ServerFactory jobServerFactory,
ServerFactory artifactServerFactory) {
return new SamzaJobServerDriver(configuration, jobServerFactory, artifactServerFactory);
}
private SamzaJobServerDriver(
SamzaServerConfiguration configuration,
ServerFactory jobServerFactory,
ServerFactory artifactServerFactory) {
this(
configuration,
jobServerFactory,
artifactServerFactory,
() -> SamzaJobInvoker.create(configuration));
}
protected SamzaJobServerDriver(
ServerConfiguration configuration,
ServerFactory jobServerFactory,
ServerFactory artifactServerFactory,
JobInvokerFactory jobInvokerFactory) {
super(configuration, jobServerFactory, artifactServerFactory, jobInvokerFactory);
}
}
```
|
Camping is a recreational activity.
Camping may also refer to:
Activities
Summer camping, an American children's activity
Backpacking (hiking), hiking and camping overnight in backcountry
Computing and Internet
Entertainment and media
Films
Camping (1917 film), an American silent film with Victor Moore
Camping (1978 film), a Dutch film by Thijs Chanowski
Camping (1990 film), a Danish film with Søren Pilmark, Per Pallesen and Rolv Wesenlund
Camping (2006 film), a French film by Fabien Onteniente
Camping (2009 film), a Danish film with Mia Lyhne and Kirsten Lehfeldt
Games
Camping (game), a team ball game played in Medieval England, a forerunner of football
Camping (video games), staying in one spot with a tactical advantage in a computer or video game
Music
"Camping", a song included on the CD Disney Children's Favorite Songs 4
Television
Camping (UK TV series)
Camping (U.S. TV series)
Camping (Parks and Recreation), a 2011 third-season episode of the comedy series Parks and Recreation
"Camping", an episode of the television series Teletubbies
People
Harold Camping (1921–2013), Christian radio preacher
Places
Camping, used in most European countries as a loanword to mean campsite
Telecommunications
A feature on a private branch exchange telephone system
See also
Camp (disambiguation)
CAMP (disambiguation)
Camper (disambiguation)
|
John Mathews may refer to:
John Mathews (American pioneer) (died 1757), settler of the Shenandoah Valley, Virginia
John Mathews (clerk) (1768–1849), American surveyor, politician and lawyer
John Mathews (lawyer) (1744–1802), Governor of South Carolina in 1782 and 1783
John Mathews (cricketer) (1884–1962), English cricketer active from 1903 to 1930 who played for Sussex
John Mathews (theologian) (born 1952), New Testament scholar
John Mathews (professor) (born 1946), Australian professor of competitive dynamics and global strategy
John Albert Mathews (born 1951), American competitive rower
J. E. Mathews, American silent film director working in Australia
John E. Mathews (1892–1955), American lawyer, legislator, and judge
John Joseph Mathews (1894–1979), Osage Nation leader
John Hobson Mathews (1858–1914), Roman Catholic historian, archivist and solicitor
John David Mathews, Pennsylvania State University professor
See also
John Matthews (disambiguation)
John Mathew (disambiguation)
|
```objective-c
#pragma once
namespace samples {
namespace fft2 {
static const float input[4] = {
0.74090862, 0.85228336,
0.71020633, 0.69013137
};
static const float output[4] = {
1.45111495, 1.54241472,
0.03070229, 0.16215199
};
}
namespace fft4 {
static const float input[8] = {
0x1.A8E4F8p-2f, 0x1.EE376Cp-3f,
0x1.E29E82p-1f, 0x1.BD43D2p-1f,
0x1.3E6038p-3f, 0x1.CC237Ep-1f,
0x1.1CB97Ep-2f, 0x1.ECC3C2p-2f
};
static const float output[8] = {
+0x1.CA82E58p+0, +0x1.3ED5C30p+1,
+0x1.4BBC5F0p-1, -0x1.526BB30p+0,
-0x1.4CF0B70p-1, -0x1.AFD1680p-3,
-0x1.081E0C0p-3, +0x1.D610000p-8
};
}
namespace fft8 {
static const float input[16] = {
0x1.98523Cp-1f, 0x1.60DCEEp-1f,
0x1.28DDCEp-1f, 0x1.3184C6p-3f,
0x1.381A28p-2f, 0x1.89A9AEp-4f,
0x1.86A262p-1f, 0x1.5C77B0p-2f,
0x1.543A9Cp-3f, 0x1.6B6768p-4f,
0x1.9F272Cp-2f, 0x1.D79460p-2f,
0x1.8F4D8Ep-5f, 0x1.351D14p-4f,
0x1.DF2BFAp-3f, 0x1.FF459Cp-5f
};
static const float output[16] = {
+0x1.A65066p+1f, +0x1.F63F24p+0f,
+0x1.82AFA2p-2f, -0x1.23A292p-1f,
+0x1.A25A26p-1f, +0x1.3C6D00p-1f,
+0x1.ACF550p-1f, +0x1.8D3520p-1f,
-0x1.547BF4p-1f, -0x1.01C700p-4f,
+0x1.DA5280p-1f, +0x1.42290Ep+0f,
+0x1.9CC78Cp-2f, +0x1.307506p-1f,
+0x1.88DD68p-2f, +0x1.DFDB58p-1f
};
}
namespace fft16 {
static const float input[32] = {
0x1.030E1Ep-1f, 0x1.7469A4p-2f,
0x1.D9ECC6p-1f, 0x1.A8F096p-2f,
0x1.7E31C2p-1f, 0x1.A212FEp-2f,
0x1.EA9412p-1f, 0x1.F59FD0p-2f,
0x1.BA8B0Ap-1f, 0x1.AE7DB2p-1f,
0x1.49DA2Cp-2f, 0x1.72D13Cp-3f,
0x1.83F174p-4f, 0x1.815008p-3f,
0x1.B3DA54p-1f, 0x1.A1E5F2p-1f,
0x1.D6F63Ep-1f, 0x1.01CF28p-3f,
0x1.D4AA36p-1f, 0x1.2F5ECEp-1f,
0x1.B6A5BEp-2f, 0x1.240B70p-2f,
0x1.7179E4p-1f, 0x1.7F19E2p-1f,
0x1.CFE398p-1f, 0x1.92646Ep-3f,
0x1.2BAEE6p-1f, 0x1.F6947Cp-2f,
0x1.C5DD26p-1f, 0x1.05F6F6p-4f,
0x1.C46E5Ap-1f, 0x1.A14BCCp-1f
};
static const float output[32] = {
+0x1.707DC8p+3f, +0x1.C15A56p+2f,
+0x1.A81C9Ap-1f, +0x1.00A50Cp-1f,
+0x1.82B37Ep-1f, -0x1.B1C5F2p-1f,
-0x1.078E8Cp+1f, +0x1.B467E4p-2f,
-0x1.32CB66p-3f, +0x1.3F607Ep+0f,
-0x1.D5B318p-3f, +0x1.249074p-4f,
-0x1.86945Cp+0f, -0x1.7D90DEp+0f,
-0x1.4571A4p+0f, +0x1.3F427Cp-5f,
-0x1.9F36A8p-1f, -0x1.09C3ECp+1f,
+0x1.8D4172p+0f, +0x1.73B30Cp-1f,
-0x1.1F8F5Ep-1f, -0x1.45690Ap-1f,
-0x1.46F9C8p+0f, +0x1.465D12p-1f,
+0x1.1D763Ap+1f, -0x1.5C32D2p-4f,
-0x1.3AA070p+0f, -0x1.720F38p-3f,
-0x1.7A4812p-5f, +0x1.9097F2p-1f,
+0x1.7FBC54p-2f, -0x1.45C688p-2f
};
}
namespace fft32 {
static const float input[64] = {
0x1.D93A22p-2f, 0x1.1A07EAp-5f,
0x1.457616p-2f, 0x1.1C6E3Cp-4f,
0x1.C1B5A4p-2f, 0x1.63CBB2p-1f,
0x1.B1DBC2p-1f, 0x1.103DE0p-1f,
0x1.8749D0p-3f, 0x1.528BBEp-2f,
0x1.5A66D6p-4f, 0x1.85E378p-1f,
0x1.6B7BAAp-1f, 0x1.4BE042p-1f,
0x1.416FEAp-1f, 0x1.185BD0p-4f,
0x1.8DD5B2p-1f, 0x1.2EE168p-1f,
0x1.4A4EE2p-1f, 0x1.ECE9C2p-1f,
0x1.961888p-3f, 0x1.97A598p-1f,
0x1.469200p-3f, 0x1.A7AE76p-1f,
0x1.C39A76p-2f, 0x1.C4A146p-1f,
0x1.9F43C0p-1f, 0x1.BF5834p-4f,
0x1.22CD6Ep-1f, 0x1.DB698Cp-1f,
0x1.288430p-1f, 0x1.B4FE36p-2f,
0x1.429398p-3f, 0x1.B4CA7Ep-1f,
0x1.225E00p-4f, 0x1.DF5ED4p-1f,
0x1.FA788Ap-2f, 0x1.AAC868p-1f,
0x1.EF25F6p-1f, 0x1.C80E82p-1f,
0x1.B40D9Cp-1f, 0x1.13D60Ap-1f,
0x1.90D116p-1f, 0x1.D01774p-1f,
0x1.80924Cp-1f, 0x1.A5AE34p-2f,
0x1.11A7DAp-1f, 0x1.112618p-1f,
0x1.86EAFEp-2f, 0x1.17E440p-1f,
0x1.26EF72p-2f, 0x1.722E82p-4f,
0x1.E8E2C6p-3f, 0x1.2ED9A4p-4f,
0x1.A783EAp-2f, 0x1.DCA8FAp-6f,
0x1.12C424p-1f, 0x1.43644Ap-3f,
0x1.F030F8p-2f, 0x1.96FA28p-1f,
0x1.0F1AD8p-2f, 0x1.9F5720p-1f,
0x1.72F744p-1f, 0x1.911D50p-1f
};
static const float output[64] = {
+0x1.F9A804p+3f, +0x1.1DB7F2p+4f,
+0x1.672C94p-1f, -0x1.4A3D9Cp+1f,
+0x1.B27418p-2f, -0x1.B14E6Cp-3f,
-0x1.ABAF6Ap-2f, +0x1.2C0C36p+1f,
-0x1.3714ECp+0f, +0x1.FD42EEp-1f,
-0x1.274494p+0f, -0x1.3A1E10p+2f,
-0x1.8CCCC6p+1f, -0x1.2B8944p-1f,
+0x1.BD06B2p-1f, -0x1.1ED11Ap-2f,
+0x1.590E08p-1f, +0x1.B76E50p-4f,
-0x1.F6FF44p-2f, -0x1.D1E062p-2f,
-0x1.5E098Cp-6f, +0x1.4B63BCp-4f,
-0x1.BF4402p-2f, +0x1.459CE0p+0f,
+0x1.54DEF8p-1f, +0x1.11D13Cp-1f,
-0x1.239C4Cp+1f, -0x1.5B311Ap+0f,
+0x1.10FD92p-2f, +0x1.3FEC78p-1f,
-0x1.4E9BDAp+0f, -0x1.95CFD4p-1f,
-0x1.C005A6p-1f, +0x1.A752E0p-2f,
+0x1.05DA20p+0f, -0x1.F777BAp-1f,
-0x1.0832AEp+1f, -0x1.E60424p-4f,
+0x1.6C27D2p+0f, -0x1.3CC866p-1f,
-0x1.2327C6p-4f, +0x1.148BD2p+0f,
+0x1.6B39F0p+0f, +0x1.8283AAp+0f,
+0x1.42E792p+1f, -0x1.A28680p+1f,
+0x1.12F404p-1f, -0x1.136422p+1f,
-0x1.9F1C9Ep-2f, -0x1.509E76p+1f,
+0x1.06FB36p-5f, -0x1.574CE6p+0f,
-0x1.2F8ED4p+0f, -0x1.037EE4p+0f,
+0x1.C45A1Ep+1f, +0x1.72A882p-4f,
-0x1.63C286p-2f, -0x1.137090p+1f,
+0x1.C5980Ap+1f, +0x1.9BE3F2p-2f,
-0x1.27CA92p+0f, +0x1.3E61BAp+1f,
-0x1.0FCA54p+1f, -0x1.A01F30p+1f
};
}
}
```
|
```linker script
/* Unlike other ROM functions which are exported using PROVIDE, which declares
weak symbols, these libgcc functions are exported using assignment,
which declares strong symbols. This is done so that ROM functions are always
used instead of the ones provided by libgcc.a.
*/
__absvdi2 = 0x4006387c;
__absvsi2 = 0x40063868;
__adddf3 = 0x40002590;
__addsf3 = 0x400020e8;
__addvdi3 = 0x40002cbc;
__addvsi3 = 0x40002c98;
__ashldi3 = 0x4000c818;
__ashrdi3 = 0x4000c830;
__bswapdi2 = 0x40064b08;
__bswapsi2 = 0x40064ae0;
__clrsbdi2 = 0x40064b7c;
__clrsbsi2 = 0x40064b64;
__clzdi2 = 0x4000ca50;
__clzsi2 = 0x4000c7e8;
__cmpdi2 = 0x40063820;
__ctzdi2 = 0x4000ca64;
__ctzsi2 = 0x4000c7f0;
__divdc3 = 0x400645a4;
__divdf3 = 0x40002954;
__divdi3 = 0x4000ca84;
__divsi3 = 0x4000c7b8;
__eqdf2 = 0x400636a8;
__eqsf2 = 0x40063374;
__extendsfdf2 = 0x40002c34;
__ffsdi2 = 0x4000ca2c;
__ffssi2 = 0x4000c804;
__fixdfdi = 0x40002ac4;
__fixdfsi = 0x40002a78;
__fixsfdi = 0x4000244c;
__fixsfsi = 0x4000240c;
__fixunsdfsi = 0x40002b30;
__fixunssfdi = 0x40002504;
__fixunssfsi = 0x400024ac;
__floatdidf = 0x4000c988;
__floatdisf = 0x4000c8c0;
__floatsidf = 0x4000c944;
__floatsisf = 0x4000c870;
__floatundidf = 0x4000c978;
__floatundisf = 0x4000c8b0;
__floatunsidf = 0x4000c938;
__floatunsisf = 0x4000c864;
__gcc_bcmp = 0x40064a70;
__gedf2 = 0x40063768;
__gesf2 = 0x4006340c;
__gtdf2 = 0x400636dc;
__gtsf2 = 0x400633a0;
__ledf2 = 0x40063704;
__lesf2 = 0x400633c0;
__lshrdi3 = 0x4000c84c;
__ltdf2 = 0x40063790;
__ltsf2 = 0x4006342c;
__moddi3 = 0x4000cd4c;
__modsi3 = 0x4000c7c0;
__muldc3 = 0x40063c90;
__muldf3 = 0x4006358c;
__muldi3 = 0x4000c9fc;
__mulsf3 = 0x400632c8;
__mulsi3 = 0x4000c7b0;
__mulvdi3 = 0x40002d78;
__mulvsi3 = 0x40002d60;
__nedf2 = 0x400636a8;
__negdf2 = 0x400634a0;
__negdi2 = 0x4000ca14;
__negsf2 = 0x400020c0;
__negvdi2 = 0x40002e98;
__negvsi2 = 0x40002e78;
__nesf2 = 0x40063374;
__nsau_data = 0x3ff96544;
__paritysi2 = 0x40002f3c;
__popcount_tab = 0x3ff96544;
__popcountdi2 = 0x40002ef8;
__popcountsi2 = 0x40002ed0;
__powidf2 = 0x400638e4;
__subdf3 = 0x400026e4;
__subsf3 = 0x400021d0;
__subvdi3 = 0x40002d20;
__subvsi3 = 0x40002cf8;
__truncdfsf2 = 0x40002b90;
__ucmpdi2 = 0x40063840;
__udiv_w_sdiv = 0x40064bec;
__udivdi3 = 0x4000cff8;
__udivmoddi4 = 0x40064bf4;
__udivsi3 = 0x4000c7c8;
__umoddi3 = 0x4000d280;
__umodsi3 = 0x4000c7d0;
__umulsidi3 = 0x4000c7d8;
__unorddf2 = 0x400637f4;
__unordsf2 = 0x40063478;
```
|
```javascript
import React from 'react';
import { storiesOf } from '@kadira/storybook';
import { Dropdown } from '@jenkins-cd/design-language';
const a2z = 'ABCDEFGHIJKLM NOPQRSTUVWXYZ';
const style = {
padding: 10,
width: 200,
};
function createOptions(text = 'Option', asObject = false) {
const options = [];
for (let index = 0; index < 200; index++) {
const label = `${text} ${options.length + 1}`;
options.push(!asObject ? label : { label });
}
return options;
}
storiesOf('DropDown', module)
.add('general', () => (<div>
<div style={style}>
<p>Default</p>
<Dropdown
options={createOptions()}
/>
</div>
<div style={style}>
<p>Disabled</p>
<Dropdown
options={createOptions()}
disabled
/>
</div>
<div style={style}>
<p>Default Value</p>
<Dropdown
options={createOptions()}
defaultOption="Option 3"
/>
</div>
<div className="Dropdown-Default" style={style}>
<p>Placeholder Styling</p>
<Dropdown
options={createOptions()}
/>
</div>
<div style={{ ...style, maxWidth: 150 }}>
<p>Truncation</p>
<Dropdown
placeholder="Truncated because the text is too long"
options={createOptions(a2z)}
/>
</div>
</div>
))
;
```
|
Toshimitsu is a masculine Japanese given name.
Possible writings
Toshimitsu can be written using different combinations of kanji characters. Some examples:
敏光, "agile, light"
敏満, "agile, full"
敏三, "agile, three"
俊光, "talented, light"
俊満, "talented, full"
俊三, "talented, three"
利光, "benefit, light"
利満, "benefit, full"
利三, "benefit, three"
年光, "year, light"
年満, "year, full"
寿光, "long life, light"
寿満, "long life, full"
The name can also be written in hiragana としみつ or katakana トシミツ.
Notable people with the name
Toshimitsu Arai (新居 利光, born 1948), Japanese voice actor.
Toshimitsu Asai (浅井 俊光, born 1983), Japanese footballer.
Toshimitsu Deyama (出山 利三, born 1965), Japanese singer.
Toshimitsu Izawa (伊沢 利光, born 1968), Japanese golfer.
Toshimitsu Kai (born 1956), Japanese golfer.
Toshimitsu Motegi (茂木 敏充, born 1955), Japanese politician.
Toshimitsu Otsubo (大坪 利満, born 1945), Japanese ice hockey player.
Toshimitsu Saito (斎藤 利三, 1534–1582), Japanese samurai.
Toshimitsu Suetsugu (末次 利光, born 1942), Japanese baseball player.
Toshimitsu Tanaka (田中 利光, 1930–2020), Japanese composer.
Toshimitsu Teshima (手嶋 敏光, born 1942), Japanese cyclist.
Toshimitsu Yoshida (吉田 寿光, born 1963), Japanese football referee.
Japanese masculine given names
Masculine given names
|
For these animals, there is documented evidence of homosexual behavior of one or more of the following kinds: sex, courtship, affection, pair bonding, or parenting, as noted in researcher and author Bruce Bagemihl's 1999 book Biological Exuberance: Animal Homosexuality and Natural Diversity.
Bagemihl writes that the presence of same-sex sexual behavior was not "officially" observed on a large scale until the 1990s due to observer bias caused by social attitudes towards nonheterosexual people, making the homosexual theme taboo. Bagemihl devotes three chapters, "Two Hundred Years at Looking at Homosexual Wildlife", "Explaining (Away) Animal Homosexuality" and "Not For Breeding Only" in his 1999 book Biological Exuberance to the "documentation of systematic prejudices" where he notes "the present ignorance of biology lies precisely in its single-minded attempt to find reproductive (or other) 'explanations' for homosexuality, transgender, and non-procreative and alternative heterosexualities." Petter Bøckman, academic adviser for the Against Nature? exhibit, stated "[M]any researchers have described homosexuality as something altogether different from sex. They must realize that animals can have sex with who they will, when they will and without consideration to a researcher's ethical principles." Homosexual behavior is found amongst social birds and mammals, particularly the sea mammals and the primates.
Sexual behavior takes many different forms, even within the same species and the motivations for and implications of their behaviors have yet to be fully understood. Bagemihl's research shows that homosexual behavior, not necessarily sex, has been documented in about five hundred species as of 1999, ranging from primates to gut worms. Homosexuality in animals is seen as controversial by social conservatives because it asserts the naturalness of homosexuality in humans, while others counter that it has no implications and is nonsensical to equate natural animal behaviors to morality. Sexual preference and motivation is always inferred from behavior. Thus homosexual behavior has been given a number of terms over the years. The correct usage of the term homosexual is that an animal exhibits homosexual behavior, however this article conforms to the usage by modern research, applying the term homosexuality to all sexual behavior (copulation, genital stimulation, mating games and sexual display behavior) between animals of the same sex.
In October 2023, biologists reported studies of animals (over 1,500 different species) that found same-sex behavior (not necessarily related to human orientation) may help improve social stability by reducing conflict within the groups studied.
Mammals
Selected mammals from the full list
Baboon
Bison
Bonobo
Brown bear
Brown Rat
Cavy
Caribou
Cat (domestic)
Cattle (domestic)
Chimpanzee
Common dolphin
Common marmoset
Dog
Dolphin
Elephant
Fox
Giraffe
Goat
Horse (domestic)
Human (Homo sapiens)
Koala
Lion
Orca
Panda
Wolf
Birds
Selected birds from the full list
Barn owl
Cassowary
Chicken
Common gull
Emu
House sparrow
Kestrel
King penguin
Mallard
Ostrich
Raven
Rock dove
Fish
Amazon molly
Anglerfish
Blackstripe topminnow
Bluegill sunfish
Char
Grayling
European bitterling
Green swordtail
Guiana leaffish
Houting whitefish
Jewel cichlid
Least darter (Microperca punctulata)
Mouthbreeding fish sp.
Salmon spp.
Southern platyfish
Ten-spined stickleback
Three-spined stickleback
Reptiles
The all-female Whiptail lizard species Aspidoscelis neomexicanus (center), which reproduces via parthenogenesis, is shown flanked by two sexual species having males, A. inornatus (left) and A. tigris (right). Research has shown that simulated mating behavior increases fertility for Aspidoscelis neomexicanus. One female lies on top of another, playing the role of the male, the lizard that was on bottom has larger eggs, in most cases. The lizards switch off this role each mating season.
Anole sp.
Bearded dragon
Blue-tailed day gecko (Phelsuma cepediana)
Broad-headed skink
Checkered whiptail lizard
Chihuahuan spotted whiptail lizard
Common ameiva
Common garter snake
Cuban green anole
Desert grassland whiptail lizard
Desert tortoise
Eastern fence lizard
Five-lined skink
Gold dust day gecko (Phelsuma laticauda)
Gopher (pine) snake
Green anole
Inagua curlytail lizard
Jamaican giant anole
Laredo striped whiptail lizard
Largehead anole
Mourning gecko
Plateau striped whiptail lizard
Red diamond rattlesnake
Red-tailed skink
Seychelles giant tortoise
Side-blotched lizard
Speckled rattlesnake
Spectacled Caiman
Water moccasin
Western rattlesnake (Crotalus viridis)
Western banded gecko
Whiptail lizard spp.
Wood turtle
Blue-tongued skink
Amphibians
Appalachian woodland salamander
Black-spotted frog
Mountain dusky salamander
Tengger desert toad
Insects
Male homosexuality has been inferred in several species of dragonflies. A survey of damsel and dragonflies reveals characteristic cloacal pincher mating damage in 20–80 percent of the males, indicating a fairly high occurrence of sexual coupling between males.
Alfalfa weevil
Australian parasitic wasp sp.
Bean weevil sp.
Bedbug and other bug spp.
Blister beetle spp.
Blowfly
Broadwinged damselfly sp.
Cabbage (small) white (butterfly)
Checkerspot butterfly
Club-tailed dragonfly spp.
Cockroach spp.
Codling moth
Common skimmer dragonfly spp.
Creeping water bug sp.
Cutworm
Digger bee
Dragonfly spp.
Eastern giant ichneumon wasp
Eucalyptus longhorned borer
Field cricket sp.
Flour beetle
Fruit fly spp.
Glasswing butterfly
Hypoponera opacior ant
Grape borer
Green lacewing
Hen flea
House fly
Ichneumon wasp sp.
Japanese scarab beetle
Larch bud moth
Large milkweed bug
Large white
Leek moth
Long-legged fly spp.
Mazarine blue
Mexican white (butterfly)
Midge sp.
Migratory locust
Monarch butterfly
Narrow-winged damselfly spp.
Parsnip leaf miner
Peach moth
Pomace fly
Queen butterfly
Red ant sp.
Red flour beetle
Rice moth
Reindeer warble fly (Hypoderma tarandi)
Rose chafer (Macrodactylus subspinosus)
Rove beetle spp.
Scarab beetle (melolonthine)
Screwworm fly
Southeastern blueberry bee
Southern green stink bug
Southern masked chafer
Southern one-year canegrub
Spreadwinged damselfly spp.
Spruce budworm moth
Stable fly sp.
Stag beetle spp.
Tsetse fly
Tropical tasar silkmoth
Vine moth
Water boatman bug
Water strider spp.
Other invertebrates
Blood-fluke
Box crab
Harvestman sp.
Hawaiian orb-weaver (spider)
Incirrate octopus spp.
Jumping spiders
Mite sp.
Spiny-headed worm
See also
Against Nature?, an exhibit at the University of Oslo's Natural History Museum that took place until 19 August 2007.
Anthropomorphism
Behavioral ecology is the study of the ecological and evolutionary basis for animal behavior
Biodiversity
Bioethics
Biology and sexual orientation
Ethology is the scientific study of animal behavior, and a branch of zoology; cognitive ethology fuses cognitive science and classical ethology to observe animals under more-or-less natural conditions
Evolutionary biology
Innate bisexuality
Sexual selection
Bibliography
Bagemihl, Bruce (1999). Biological Exuberance: Animal Homosexuality and Natural Diversity. St. Martin's Press
Caramagno, Thomas C (2002). Irreconcilable Differences? Intellectual Stalemate in the Gay Rights Debate; Praeger/Greenwood, .
Cooper, J.B. "An Exploratory Study on African Lions" in Comparative Psychology Monographs 17:1-48.
Cziko, Gary (2000) The Things We Do: Using the Lessons of Bernard and Darwin to Understand the What, How, and Why of Our Behavior; MIT Press, .
de Waal, Frans B. M. (2001) The Ape and The Sushi Master: Cultural Reflections by a Primatologist; Basic Books (chapter Bonobos and Fig Leaves).
Dunkle, S.W. (1991), "Head damage from mating attempts in dragonflies (Odonata:Anisoptera)". Entomological News 102, pp. 37–41. Retrieved on 16 June 2010.
Eaton, R. L. (1974). "The Biology and Social Behavior of Reproduction in the Lion" in Eaton, ed. The World's Cats, vol. II; pp. 3–58; Seattle.
Forger, Nancy G., Laurence G. Frank, S. Marc Breedlove, Stephen E. Glickman (6 December 1998). "Sexual Dimorphism of Perineal Muscles and Motoneurons in Spotted Hyenas"; The Journal of Comparative Neurology, Volume 375, Issue 2, Pages 333 - 343. Retrieved 11 September 2007.
Goudarzi, Sara (16 November 2006). "Gay Animals Out of the Closet?: First-ever Museum Display Shows 51 Species Exhibiting Homosexuality". MSNBC. Retrieved on 12 September 2007.
Holekamp, Kay E. (2003). Research: Spotted Hyena - Introduction and Overview. Michigan State University, Department of Zoology]. Retrieved 16 June 2010.
Kick, Russ (2001). You Are Being Lied to: The Disinformation Guide to Media Distortion, Historical Whitewashes and Cultural Myths. The Disinformation Company, . Retrieved on 18 November 2007.
News-medical.net (23 October 2006). "1,500 Animal Species Practice Homosexuality" Retrieved on 10 September 2007.
Poiani, Aldo (2010). Animal Homosexuality: A Biosocial Perspective. Cambridge University Press.
Roselli, Charles E., Kay Larkin, John A. Resko, John N. Stellflug and Fred Stormshak (2004). "The Volume of a Sexually Dimorphic Nucleus in the Ovine Medial Preoptic Area/Anterior Hypothalamus Varies with Sexual Partner Preference". Endocrinology, Department of Physiology and Pharmacology, Oregon Health & Science University (C.E.R., K.L., J.A.R.), Portland, Oregon; Department of Animal Sciences, Oregon State University (F.S.), Corvallis, Oregon; and Agricultural Research Service, United States Sheep Experiment Station (J.N.S.), Dubois, Idaho, Vol. 145, No. 2. Retrieved on 10 September 2007.
Roughgarden, Joan (2004). Evolutions Rainbow: Diversity, Gender and Sexuality in Nature and People; University of California Press, Berkeley, pages p. 13-183.
Schaller, G. B. (1972). The Serengeti Lion; University of Chicago Press.
Smith, Dinitia (7 February 2004). "Love That Dare Not Squeak Its Name" New York Times. Retrieved on 10 September 2007. Reprinted as "Central Park Zoo's Gay Penguins Ignite Debate", San Francisco Chronicle.
Sommer, Volker & Paul L. Vasey (2006). Homosexual Behaviour in Animals, An Evolutionary Perspective. Cambridge University Press, Cambridge; ISBN 0521864461.
Srivastav, Suvira (15–31 December 2001). "Lion, Without Lioness"
Stein, Edward (1999) The Mismeasure of Desire: The Science, Theory, and Ethics of Sexual Orientation; Oxford University Press, US; .
Tatarnic, Nikolai J., Gerasimos Cassis, Dieter F. Hochuli; 22 March 2006 "Traumatic insemination in the plant bug genus Coridromius Signoret (Heteroptera: Miridae)" Biology Letters Journal Volume 2, Number 1, pg 58-61: Royal Society Publishing; Retrieved 16 June 2010.
Terry, Jennifer (2000) "'Unnatural Acts' In Nature: The Scientific Fascination with Queer Animals"; GLQ: A Journal of Lesbian and Gay Studies (6(2):151-193; OI:10.1215/10642684-6-2-151); Duke University Press.
Utzeri, C. & C. Belfiore (1990): "Anomalous tandems in Odonata". Fragmenta Entomologica 22(2), pp. 271–288. Retrieved 11 September 2007.
Vasey, Paul L. (1995), "Homosexual Behaviour in Primates: A Review of Evidence and Theory"; International Journal of Primatology 16: p 173-204.
Zimmer, Carl (2000); Parasite Rex: Inside the Bizarre World of Nature's Most Dangerous Creatures; Simon and Schuster, . Retrieved 18 November 2007.
References
Animals
Homosexual
|
```python
import functools
from typing import Optional
from dbt.events.types import InternalDeprecation
from dbt_common.events.functions import warn_or_error
def deprecated(suggested_action: str, version: str, reason: Optional[str]):
def inner(func):
@functools.wraps(func)
def wrapped(*args, **kwargs):
name = func.__name__
warn_or_error(
InternalDeprecation(
name=name,
suggested_action=suggested_action,
version=version,
reason=reason,
)
) # TODO: pass in event?
return func(*args, **kwargs)
return wrapped
return inner
```
|
```html
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>libdill</title>
<link rel="stylesheet" type="text/css" href="main.css">
</head>
<body>
<h1>libdill: Structured Concurrency for C</h1>
<ul id='toplist'>
<li><a href="index.html">Home</a></li>
<li><a href="download.html">Download</a></li>
<li><a href="documentation.html">Documentation</a></li>
<li><a href="tutorial.html">Tutorials</a></li>
<li><a href="faq.html">FAQ</a></li>
</ul>
<h1 id="name">NAME</h1>
<p>choose - performs one of multiple channel operations</p>
<h1 id="synopsis">SYNOPSIS</h1>
<div class="sourceCode"><pre class="sourceCode c"><code class="sourceCode c"><span class="pp">#include </span><span class="im"><libdill.h></span>
<span class="kw">struct</span> chclause {
<span class="dt">int</span> op;
<span class="dt">int</span> ch;
<span class="dt">void</span> *val;
<span class="dt">size_t</span> len;
};
<span class="dt">int</span> choose(
<span class="kw">struct</span> chclause* clauses,
<span class="dt">int</span> nclauses,
<span class="dt">int64_t</span> deadline);</code></pre></div>
<h1 id="description">DESCRIPTION</h1>
<p>Accepts a list of channel operations. Performs one that can be done first. If multiple operations can be done immediately, the one that comes earlier in the array is executed.</p>
<p><strong>clauses</strong>: Operations to choose from. See below.</p>
<p><strong>nclauses</strong>: Number of clauses.</p>
<p><strong>deadline</strong>: A point in time when the operation should time out, in milliseconds. Use the <strong>now</strong> function to get your current point in time. 0 means immediate timeout, i.e., perform the operation if possible or return without blocking if not. -1 means no deadline, i.e., the call will block forever if the operation cannot be performed.</p>
<p>The fields in <strong>chclause</strong> structure are as follows:</p>
<ul>
<li><strong>op</strong>: Operation to perform. Either <strong>CHSEND</strong> or <strong>CHRECV</strong>.</li>
<li><strong>ch</strong>: The channel to perform the operation on.</li>
<li><strong>val</strong>: Buffer containing the value to send or receive.</li>
<li><strong>len</strong>: Size of the buffer.</li>
</ul>
<h1 id="return-value">RETURN VALUE</h1>
<p>In case of success the function returns index of the clause that caused the function to exit. In case of error it returns -1 and sets <strong>errno</strong> to one of the values below.</p>
<p>Even if an index is returned, <strong>errno</strong> may still be set to an error value. The operation was successfull only if <strong>errno</strong> is set to zero.</p>
<h1 id="errors">ERRORS</h1>
<ul>
<li><strong>ECANCELED</strong>: Current coroutine was canceled.</li>
<li><strong>EINVAL</strong>: Invalid argument.</li>
<li><strong>ETIMEDOUT</strong>: Deadline was reached.</li>
</ul>
<p>Additionally, if the function returns an index it can set <strong>errno</strong> to one of the following values:</p>
<ul>
<li><strong>0</strong>: Operation was completed successfully.</li>
<li><strong>EBADF</strong>: Invalid handle.</li>
<li><strong>EINVAL</strong>: Invalid parameter.</li>
<li><strong>EMSGSIZE</strong>: The peer expected a message with different size.</li>
<li><strong>ENOTSUP</strong>: Operation not supported. Presumably, the handle isn't a channel.</li>
<li><strong>EPIPE</strong>: Channel has been closed with <strong>chdone</strong>.</li>
</ul>
<h1 id="example">EXAMPLE</h1>
<div class="sourceCode"><pre class="sourceCode c"><code class="sourceCode c"><span class="dt">int</span> val1 = <span class="dv">0</span>;
<span class="dt">int</span> val2;
<span class="kw">struct</span> chclause clauses[] = {
{CHSEND, ch, &val1, <span class="kw">sizeof</span>(val1)},
{CHRECV, ch, &val2, <span class="kw">sizeof</span>(val2)}
};
<span class="dt">int</span> rc = choose(clauses, <span class="dv">2</span>, now() + <span class="dv">1000</span>);
<span class="cf">if</span>(rc == <span class="dv">-1</span>) {
perror(<span class="st">"Choose failed"</span>);
exit(<span class="dv">1</span>);
}
<span class="cf">if</span>(rc == <span class="dv">0</span>) {
printf(<span class="st">"Value %d sent.</span><span class="sc">\n</span><span class="st">"</span>, val1);
}
<span class="cf">if</span>(rc == <span class="dv">1</span>) {
printf(<span class="st">"Value %d received.</span><span class="sc">\n</span><span class="st">"</span>, val2);
}</code></pre></div>
<h1 id="see-also">SEE ALSO</h1>
<p><strong>chdone</strong>(3) <strong>chmake</strong>(3) <strong>chmake_mem</strong>(3) <strong>chrecv</strong>(3) <strong>chsend</strong>(3) <strong>now</strong>(3)</p>
</body>
```
|
```kotlin
package com.pierfrancescosoffritti.androidyoutubeplayer.core.player.listeners
import android.view.View
/**
* Interface used to keep track of full screen events
*/
interface FullscreenListener {
/**
* Notify the host application that the player has entered full screen mode
* (the full screen button in the player UI has been clicked).
* After this call, the video will no longer be rendered in the [YouTubePlayerView],
* but will instead be rendered in [fullscreenView].
* The host application should add this View to a container that fills the screen
* in order to actually display the video full screen.
*
* The application can explicitly exit fullscreen mode by invoking [exitFullscreen]
* (for example when the user presses the back button).
* However, the player will show its own UI to exist fullscreen.
* Regardless of how the player exits fullscreen mode, [onEnterFullscreen] will be invoked,
* signaling for the application to remove the custom View.
*/
fun onEnterFullscreen(fullscreenView: View, exitFullscreen: () -> Unit)
/**
* Notify the host application that the player has exited full screen mode.
* The host application must hide the custom View (the View which was previously passed to
* [onEnterFullscreen]). After this call, the video will render in the player again.
*/
fun onExitFullscreen()
}
```
|
Lury-sur-Arnon (, literally Lury on Arnon) is a commune in the Cher department in the Centre-Val de Loire region of France.
Geography
An ancient fortified farming village situated by the river Arnon, some south of Vierzon at the junction of the D30, D918 and the D68 roads.
Population
Sights
The church of St. Paul, dating from the nineteenth century.
The castle, dating from the twelfth century.
The restored Gothic chapel.
A twelfth-century gatehouse tower.
See also
Communes of the Cher department
References
Communes of Cher (department)
|
```javascript
Don't assume that HTML script tags are always run sequentially
Form a `URL` from its parts
Modify a website's URL
Drag and Drop API
MediaDevices.getUserMedia()
```
|
Adam Smith Business School (formerly known as Adam Smith School of Economics and Finance) is the business school of the University of Glasgow. It is named after the father of economics, Adam Smith (1723–1790), who was Professor of Moral Philosophy at the university.
The first chair of accountancy was established within the Faculty of Law in 1925, with Bachelor of Accounting and Master of Accounting degrees being introduced in 1968.
In 1971, the Scottish Business School (SBS) was established as a collaboration between the universities of Edinburgh, Glasgow and Strathclyde. The SBS launched a part-time MBA at Glasgow University in 1976. In 1978, Andrew Thomson was appointed Professor of Business Policy in Glasgow's recently established Department of Management Studies. The business school was established in 1986.
The school continues research in international finance, international economics and macroeconomics. the business school offered four undergraduate and 35 postgraduate degrees (including PhDs) and is one of few institutions holding triple accreditation from AACSB, AMBA and EQUIS.
To commemorate 300 years since the birth of Adam Smith in 2023, students of the school designed a school tartan which is recognised in the Scottish Register of Tartans.
Notable people
Alumni
Josue Ortega
Professors
Anna Bogomolnaia
Ronald MacDonald
Hervé Moulin
References
Business schools in Scotland
Hillhead
Schools of the University of Glasgow
|
Maitreya () or Metteyya (), also Maitreya Buddha or Metteyya Buddha, is regarded as the future Buddha of this world in Buddhist eschatology. As the fifth and final Buddha of the current kalpa, Maitreya's teachings will be focused around re-establishing the dharma, a vital concept in Hinduism, Buddhism, and Jainism.
In all branches of Buddhism, Maitreya Buddha is viewed as the direct successor of Gautama Buddha. (In some Buddhist literature, such as the Amitabha Sutra and the Lotus Sutra, he is referred to as Ajita). According to scriptures, Maitreya's teachings will be similar to those of Gautama Buddha (also known as Śākyamuni Buddha). The arrival of Maitreya is prophesied to occur during an era when the teachings of Gautama Buddha have been disregarded or largely forgotten.
Despite many religious figures and spiritual leaders claiming to be Maitreya throughout history, diverse Buddhist sects insist that these are false claims, while underscoring that Maitreya has yet to appear, and that he is the Buddha of the future. While Maitreya is said to be a bodhisattva who has long been prophesied to appear on Earth (being mentioned in scriptures as early as the 3rd century CE), traditional Buddhists belief that Maitreya at present resides in Tushita heaven. On account of his enlightenment and his relinquishing any sense of personal self or ego, Maitreya is poised to teach self-realization, as well as right action and right relationship, or the Dharma.
Maitreya has also been employed in a millenarian role by many non-Buddhist philosophies and religions, such as Theosophy, the White Lotus, as well as by modern new religious movements, such as Yiguandao.
Sources
The name Maitreya is derived from the Sanskrit word "friendship", which is in turn derived from the noun mitra, signifying "friend". The Pali form Metteyya is mentioned in the Cakkavatti-Sīhanāda Sutta (Digha Nikaya 26) of the Pāli Canon, and also in chapter 28 of the Buddhavamsa. Most of the Buddha's sermons are presented as having been presented in answer to a question, or in some other appropriate context, but this sutta has a beginning and ending in which the Buddha is talking to monks about something totally different. This leads scholar Richard Gombrich to conclude that either the whole sutta is apocryphal or that it has at least been tampered with.
In the Greco-Buddhist art of Gandhara, in the first centuries CE in northern India, Maitreya was the most popular figure to be represented along with Gautama Buddha (often called Śākyamuni "sage of the Shakya"). In 4th- to 6th-century China, "Buddhist artisans used the names Shakyamuni and Maitreya interchangeably... indicating both that the distinction between the two had not yet been drawn and that their respective iconographies had not yet been firmly set". An example is the stone sculpture found in the Qingzhou cache dedicated to Maitreya in 529 CE as recorded in the inscription (currently in the Qingzhou Museum, Shandong). The religious belief of Maitreya apparently developed around the same time as that of Amitābha, as early as the 3rd century CE.
Characteristics
One mention of the prophecy of Maitreya is in the . It implies that Maitreya is a teacher of meditative trance sādhanā and states that gods, men and other beings:
General description
In the Greco-Buddhist art of Gandhara, Maitreya is represented as a northern Indian nobleman, holding a kumbha in his left hand. Sometimes this is a "wisdom urn" (Tibetan: Bumpa). He is flanked by his two acolytes, the brothers Asanga and Vasubandhu, who founded the Yogacara tradition.
The Maitreyasamiti was an extensive Buddhist play in pre-Islamic Central Asia. The Maitreyavyakarana (in Sataka form) in Central Asia and the Anagatavamsa of South India also mention him.
Maitreya's Heaven
Maitreya currently resides in the Heaven (Pāli: Tusita), said to be reachable through meditation. Gautama Buddha also lived here before he was born into the world as all bodhisattvas live in the Heaven before they descend to the human realm to become Buddhas. Although all bodhisattvas are destined to become Buddhas, the concept of a bodhisattva differs greatly in Theravada and Mahayana Buddhism. In Theravada Buddhism, a bodhisattva is one who is striving for full enlightenment (Arahantship in Pali), whereas in Mahayana Buddhism, a bodhisattva is one who vows to achieve enlightenment for the purpose of helping all sentient beings (a common misconception being that they delay their enlightenment, which is inaccurate according to the Nalanda tradition).
In Mahayana Buddhism, Buddhas preside over pure lands, such as Amitābha over Sukhavati. Once Maitreya becomes a buddha, he will rule over the Ketumati pure land, an earthly paradise sometimes associated with the city of Varanasi (also known as Benares) in Uttar Pradesh, India, and in other descriptions, the Shambhala.
In Theravada Buddhism, Buddhas are born as unenlightened humans, and are not rulers of any paradise or pure land. Maitreya's arising would be no different from the arising of Gautama Buddha, as he achieved full enlightenment as a human being and died, entering parinibbana (nirvana-after-death).
Activity of Maitreya in the current age
In Mahayana schools, Maitreya is traditionally said to have revealed the Five Treatises of Maitreya through Asanga. These texts are the basis of the Yogacara tradition and constitute the majority of the third turning within the Three Turnings of the Wheel of Dharma.
Future coming of Maitreya
According to Buddhist tradition, each kalpa has 1,000 Buddhas. The previous kalpa was the vyuhakalpa (Glorious aeon), and the present kalpa is called the bhadrakalpa (Auspicious aeon). The Seven Buddhas of Antiquity (Saptatathāgata) are seven Buddhas which bridge the vyuhakalpa and the bhadrakalpa:
Vipassī (the 998th Buddha of the vyuhakalpa)
Sikhī (the 999th Buddha of the vyuhakalpa)
Vessabhū (the 1000th and final Buddha of the vyuhakalpa)
Kakusandha (the first Buddha of the bhadrakalpa)
Koṇāgamana (the second Buddha of the bhadrakalpa)
Kassapa (the third Buddha of the bhadrakalpa)
Gautama (the fourth and present Buddha of the bhadrakalpa)
Maitreya will be the fifth and future Buddha of the bhadrakalpa, and his arrival will occur after the teachings of Gautama Buddha are no longer practiced.
The coming of Maitreya will be characterized by a number of physical events. The oceans are predicted to decrease in size, allowing Maitreya to traverse them freely. Maitreya will then reintroduce true dharma to the world.
Maitreya's arrival will signify the end of the middle time, the time between the fourth Buddha, Gautama Buddha, and the fifth Buddha, Maitreya, which is viewed as a low point of human existence. According to the Cakkavatti Sutta: The Wheel-turning Emperor, Digha Nikaya 26 of the Sutta Pitaka of the Pāli Canon, Maitreya Buddha will be born in a time when humans will live to an age of eighty thousand years, in the city of Ketumatī (present Varanasi), whose king will be the Cakkavattī Sankha. Sankha will live in the palace where once dwelt King Mahāpanadā, but later he will give the palace away and will himself become a follower of Maitreya Buddha.
The scriptures say that Maitreya will attain bodhi in seven days (which is the minimum period), by virtue of his many lives of preparation for buddhahood similar to those reported in the Jataka tales.
At this time a notable teaching he will start giving is that of the ten non-virtuous deeds (killing, stealing, sexual misconduct, lying, divisive speech, abusive speech, idle speech, covetousness, harmful intent and wrong views) and the ten virtuous deeds (the abandonment of: killing, stealing, sexual misconduct, lying, divisive speech, abusive speech, idle speech, covetousness, harmful intent and wrong views).
The Arya Maitreya Mandala, an order founded by Anagarika Govinda, is based on the idea of the future coming of Maitreya.
Buddhist texts from several traditions say that beings in Maitreya's time will be much bigger than during the time of Sakyamuni. In one prophecy his disciples are contemptuous of Mahakasyapa, whose head is no larger than an insect to them. Buddha's robe barely covers two fingers making them wonder how tiny Buddha was. Mahākāśyapa is said to be small enough in comparison to cremate in the palm of Maitreya's hand.
Foretold biography
Maitreya will be born to the Brahmins, Tubrahmā (father) and Brahmavadi (mother) in Ketumatī, which will be ruled by King Saṅkha, a Chakravarti. Maitreya's spouse will be Princess Sandamukkhī. His son will be Brahmavaṁsa. After the birth of his son, Maitreya will leave to practice asceticism. He will practice for seven days. After the practice, he will be awakened under a Mesua ferrea tree. The disciples of Maitreya Buddha are:
Asoka, an Agraśrāvaka and the right-hand chief disciple
Brahmadeva, an Agraśrāvaka and the left-hand chief disciple
Sumana, the right-hand Agasāvikā
Padumā, the left-hand Agasāvikā
Sīha, a primary attendant.
Maitreya will be 88 cubits (132 feet, 40 meters) tall and will live for 88,000 years. Like Maṅgala Buddha, his rays will make people hard to distinguish between day and night. His teachings will preserve for the next 180,000 years. According to the commentary of Anāgatavamsa, his teaching will last for 360,000 years.
Nichiren Buddhism and Maitreya as metaphor
According to the Lotus Sutra in Nichiren Buddhism, all people possess the potential to reveal an innate Buddha nature during their own lifetimes, a concept which may appear to contradict the idea of Buddha as savior or messiah.
Although Maitreya is a significant figure in the Lotus Sutra, the explanation of Nichiren is that Maitreya is a metaphor of stewardship and aid for the Bodhisattvas of the Earth, as written in the Lotus Sutra:
In much of his writing, Nichiren mentions the traditional Buddhist views on Maitreya but explains that the propagation of the Eternal Dharma of the Lotus Sutra was entrusted by Shakyamuni to the Bodhisattvas of earth: Thus, each individual can embody the character of the Maitreya because he is a metaphor for compassion:
Maitreya claimants
The following list is just a small selection of those people who claimed or claim to be the incarnation of Maitreya. Many have either used the Maitreya incarnation claim to form a new Buddhist sect or have used the name of Maitreya to form a new religious movement or cult.
In 613 the monk Xiang Haiming claimed himself Maitreya and adopted an imperial title.
In 690 Wu Zetian, empress regnant of the Wu Zhou interregnum (690–705), proclaimed herself an incarnation of the future Buddha Maitreya, and made Luoyang the "holy capital." In 693 she temporarily replaced the compulsory Dao De Jing in the curriculum with her own Rules for Officials.
Gung Ye, a Korean warlord and king of the short-lived state of Taebong during the 10th century, claimed himself as the living incarnation of Maitreya and ordered his subjects to worship him. His claim was widely rejected by most Buddhist monks and later he was dethroned and killed by his own servants.
Bahá'u'lláh (1817–1892), the Prophet-Founder of the Bahá'í Faith, is recognized by Bahá'ís as the promised Maitreya Buddha and Promised One of all religions.
Lu Zhongyi (1849–1925), the 17th patriarch of Yiguandao, claimed to be an incarnation of Maitreya.
L. Ron Hubbard, founder of the belief systems Dianetics and Scientology, suggested he was "Metteya" (Maitreya) in the 1955 poem Hymn of Asia. Numerous editors and followers of Hubbard claim that in the book's preface, specific physical characteristics said to be outlined—in unnamed Sanskrit sources—as properties of the coming Maitreya were properties with which Hubbard's appearance supposedly aligned.
Samael Aun Weor (1917–1977) – stated in The Aquarian Message that "the Maitreya Buddha Samael is the Kalki Avatar of the New Age." The Kalkian Avatar and Maitreya Buddha, he claimed, are the same "White Rider" of the Book of Revelation.
Adi Da was suggested by his devotees to be Maitreya:
Followers of B.R. Ambedkar in the Dalit Buddhist Movement regard him as a bodhisattva, the Maitreya, although he never claimed it himself.
Many scholars and analysts claimed Hindu Avatar Kalki as Maitreya.
Some Muslim writers, including those of the Ahmadiyya Muslim Community, claimed Islamic prophet Muhammad as Maitreya.
Maitreya sects in China
Pre-Maitreyan Buddhist messianic rebellions
Southern and Northern Dynasties
515: The 'Chinese Rebellion'. In the late summer of that year, the renegade monk Faqing 法慶 married a nun and formed a sect in the Northern Wei province of Jizhou 冀州 (in the southern part of today's Hebei province) with the assistance of a local aristocrat named Li Guibo 李歸伯. Li Guibo was given the titles of Tenth-stage Bodhisattva, Commander of the Demon-vanquishing Army, and King who Pacifies the Land of Han by Faqing.
Using drugs to send its members into a killing frenzy , and promoting them to Tenth-Stage Bodhisattva as soon as they killed ten enemies, the sect seized a prefecture and murdered all the government officials in it. Their slogan was "A new Buddha has entered the world; eradicate the demons of the former age", and they would kill all monks and nuns in the monasteries that they captured, also burning all the sutras and icons . After defeating a government army and growing to a size of over 50,000, the rebel army was finally crushed by another government army of 100,000. Faqing, his wife, and tens of thousands of his followers were beheaded, and Li Guibo was also captured later and publicly executed in the capital city Luoyang.
The Fozu Tongji (Comprehensive Records of the Buddha), a chronicle of Buddhist history written by the monk Zhipan in 1269, also contains an account of the Rebellion, but with significant deviations from the original account, such as dating the rebellion to 528 rather than 515.
516: The Moonlight Child Rebellion. Toward the end of that year, another sect was discovered by local authorities in Yanling, Jizhou. A man named Fa Quan and his associates were claiming that an eight-year-old child Liu Jinghui was a Bodhisattva called the Moonlight Child (yueguang tongzi pusa; 月光童子菩萨), and that he could transform into a snake or a pheasant. They were arrested and sentenced to death on suspicion of seditious intent, but Jinghui had his sentence commuted to banishment on account of his youth and ignorance.
517: Early in the spring of that year, surviving remnants of the rebels regrouped and mounted a sudden attack on the capital of Yingzhou province, which lay just northwest of their original base in Bohai prefecture. They were repelled only after a pitched battle with an army of slaves and attendants led by Yuwen Yan, the son of the provincial governor, and nothing more is known of their fate.
Although a "new Buddha" was mentioned, these rebellions are not considered "Maitreyan" by modern scholars. However, they would be a later influence on the rebel religious leaders that made such claims. Therefore, it is important to mention these rebellions in this context.
Maitreyan rebellions
Sui Dynasty
610: On the first day of the Chinese New Year, dozens of rebels dressed in white, burning incense and holding flowers proclaimed their leader as Maitreya Buddha and charged into the imperial palace through one of its gates, killing all the guards before they were themselves killed by troops led by an imperial prince. A massive investigation in the capital (Chang'an) implicated over a thousand families.
613: A skilled magician named Song Zixian claimed to be Maitreya in Tang County (northwest of Yingzhou), and allegedly could transform into the form of a Buddha and make his room emit a glow every night. He hung a mirror in a hall that could display an image of what a devotee would be reincarnated as: a snake, a beast or a human being. Nearly a thousand "from near and far" joined his sect every day, and he plotted to first hold a Buddhist vegetarian banquet, or wuzhe fohui, and then attack the emperor who was then touring Yingzhou. The plot was leaked, and Song was arrested and executed, along with over a thousand families of his followers.
613: The monk Xiang Haiming claimed to be Maitreya in Fufeng prefecture (western Shaanxi) and led a rebellion. The elite of the Chang'an area hailed him as dasheng, or holy man, because they had auspicious dreams after following him, and his army swelled to several tens of thousands before he was defeated by government troops.
Tang Dynasty
710: Wang Huaigu declared, "The Shakyamuni Buddha has declined; a new Buddha is about to appear. The House of Li is ending, and the House of Liu is about to rise".
Song Dynasty
1047: Army officer Wang Ze led a revolt of Buddhists expecting Maitreya; they took over the city of Beizhou in Hebei before they were crushed. The Song Dynasty government declared Maitreya Sects to be "heresies and unsanctioned religions". Tens of thousands of Maitreya Sect followers were killed.
Yuan and Ming Dynasty
1351: The Red Turban Rebellion (aka The First White Lotus Rebellion). Han Shantong (韓山童), leader of the White Lotus Society, and Army Commander Liu Futong () rebelled against the Mongols of the Yuan dynasty. Shantong's anti-Mongol slogan was "The empire is in utter chaos. Maitreya Buddha has incarnated, and the Manichaean King of Light has appeared in this world."
In 1355, Han Shantong's son, Han Lin'er (, 1355–1368?), was proclaimed "Emperor of the Great [Latter] Song" (大宋, referring to the defunct Song dynasty) by Liu Futong. Liu Futong claimed Han Lin'er was a direct descendant of the Zhao royal family who ruled the Song Dynasty. After Liu Futong's death, Zhu Yuanzhang took up command of the Red Turban Rebellion and later assassinated Han Lin'er to become the Hongwu Emperor of the Ming dynasty. (See History) According to Beijing University,
This suggests that the Ming dynasty was named after the White Lotus figures of the "Big and Little Bright Kings".
Qing Dynasty
1796: The White Lotus Rebellion (aka The Second White Lotus Rebellion). It broke out among impoverished settlers in the mountainous region that separates Sichuan province from Hubei and Shaanxi provinces. It apparently began as a White Lotus Society protest against heavy taxes imposed by Manchu rulers of the Qing Dynasty.
The Yi He Tuan (義和團), often called in English the "Society of Harmonious Fists" was a 19th-century martial-sect inspired in part by the White Lotus Society. Members of the "Harmonious Fists" became known as "Boxers" in the west because they practiced Chinese martial arts.
1899: The Boxer Rebellion (義和團之亂). Chinese rebellion from November 1899 to September 7, 1901, against foreign influence in such areas as trade, politics, religion and technology that occurred in China during the final years of the Qing Dynasty. By August 1900, over 230 foreigners, tens of thousands of Chinese Christians, an unknown number of rebels, their sympathizers and other innocent bystanders had been killed in the chaos. The uprising crumbled on August 14, 1900, when 20,000 foreign troops entered the Chinese capital, Peking (Beijing).
Albeit not in the name of Maitreya, both rebellions were perpetrated solely or in part by the White Lotus Society, a rebellious Maitreya sect.
Speculation
Some have speculated that inspiration for Maitreya may have come from Mithra, the ancient Indo-Iranian deity. The primary comparison between the two characters appears to be the similarity of their names, while a secondary comparison is that both were expected to come in the future.
Paul Williams claims that some Zoroastrian ideas like Saoshyant influenced the beliefs about Maitreya, such as "expectations of a heavenly helper, the need to opt for positive righteousness, the future millennium, and universal salvation". Possible objections are that these characteristics are not unique to Zoroastrianism, nor are they necessarily characteristic of the belief in Maitreya.
Non-Buddhist views
Theosophy
In Theosophy, Maitreya (or Lord Maitreya) has multiple aspects signifying not just the future Buddha, but similar concepts from other religious or spiritual traditions. Although many individuals misconstrue Theosophy as a religion, Theosophy is actually syncretic and the outgrowth of many different spiritual beliefs of both East and West, as well as of diverse philosophical traditions and science.
In early 20th century, leading Theosophists became convinced that a return of Maitreya as a "World Teacher" was imminent. At this time, a South Indian boy, Jiddu Krishnamurti, was thought to be destined as the "vehicle" for Maitreya; however, in his early 30s, Krishnamurti, himself, declined to serve in this role. Theosophists contend that, in all cases, Maitreya and the Masters of Wisdom (the Beings Who work directly under Maitreya) never infringe on the free-will of any individual or of humanity (as this would defy the Law of Cause and Effect or Karma). Thus Krishnamurti's choice was considered sacrosanct, not heretical, by many, but not all, Theosophists.
Post-theosophical movements
Since the growth of Theosophy in the late 19th century, diverse religions and spiritual movements have adopted and reinterpreted older Jain, Hindu and Buddhist beliefs about Maitreya. Share International, for example, equates Maitreya with the prophesied figures of multiple religious traditions, claims that Maitreya is already present in the world but is preparing to make an open declaration of his presence in the near future. They claim that he is here to inspire mankind to create a new era based on sharing and justice.
In the beginning of the 1930s, the Ascended Master Teachings placed Maitreya in the "Office of World Teacher" until 1956, when he was described as moving on to the "Office of Planetary Buddha" and "Cosmic Christ" in their concept of a Spiritual Hierarchy.
In 1911, Rudolf Steiner claimed "Roughly three thousand years after our time the world will experience the Maitreya Buddha incarnation, which will be the last incarnation of Jeshu ben Pandira. This Bodhisattva, who will come as Maitreya Buddha, will also come in a physical body in our century in his reincarnation in the flesh—but not as Buddha—and he will make it his task to give humanity all the true concepts about the Christ Event." Steiner was careful to distinguish Jeshu ben Pandira as somebody entirely distinct from Jesus of Nazareth, as Maitreya was said to be entirely distinct from Jesus (but in moment-to-moment relationship with him the last 3 years of his life).
Ahmadiyya
The Ahmadiyyas believe Mirza Ghulam Ahmad (1835–1908) fulfilled expectations regarding the Maitreya Buddha.
The founder has given the whole account about the truth of forthcoming of Jesus Christ and his travel via Tibet and the transformation of word "Masiha" to "Metteyya" in one of his Prolific writings "Jesus in India" (Maseeh Hindustan Mai).
Baháʼí Faith
Followers of the Baháʼí Faith believe that Bahá'u'lláh is the fulfillment of the prophecy of appearance of Maitreya, the fifth Buddha. Baháʼís believe that the prophecy that Maitreya will usher in a new society of tolerance and love has been fulfilled by Bahá'u'lláh's teachings on world peace.
Islam
Islamic prophet Dhu al-Kifl has been identified with the Buddha based on Surah 95:1 of the Qur'an, which references a fig tree—a symbol that does not feature prominently in the lives of any of the other prophets mentioned in the Qur'an. It has meanwhile been suggested that the name Al-Kifl could be a reference to Kapilavastu, the home of Siddartha Gautama as a boy. On the other hand, some of the preachers of Islam cite Buddhist sources to claim that "Maitreya" refers to Islamic Prophet Muhammad. The Muslim Times website, for example, cites The Gospel of Buddha by Carus with the following quote of Buddha:
Korean shamanism
In many East Asian folk religions, including Korean shamanism, a deity by the name of Maitreya appears as an ancient creator god or goddess. A malevolent usurper deity by the name of Shakyamuni (the historical Buddha) claims dominion over Maitreya's world, and the two engage in a flower-growing contest to decide who will rule the world. Maitreya grows the flower while Shakyamuni cannot, but the usurper steals it while the creator sleeps. Shakyamuni thus becomes the ruler of the world and brings suffering and evil to the world.
Comparative Religion
Islam
The Mahdi figure in Islam can be likened to the Maitreya figure of Buddhism. Both are prophesied saviors sharing a messianic-like quality, and both are predicted to exert a form of world rulership.
Gallery
See also
Baháʼu'lláh, similar eschatological figure in the Baháʼí Faith
Budai, a traditional manifestation of Maitreya
Christ, similar eschatological figure in Christianity
History of Buddhism in India
Dalit Buddhist movement
Decline of Buddhism in the Indian subcontinent
Navayana
Spread of Buddhism
Index of Buddhism-related articles
Kalki
Kalki Purana
Leshan Giant Buddha
Lord of Light
Mahdi, similar eschatological figure in Islam
Maitreya (Benjamin Creme)
Maitreya (Mahābhārata)
Maitreya Project
Maitreya (Theosophy)
Messiah, similar eschatological figure in Christianity and Judaism
Paraclete, similar eschatological figure in Christianity
Saoshyant, similar eschatological figure in Zoroastrianism
Secular Buddhism
Notes
Further reading
Mipham, Jamgon; Maitreya; Shenga, Khenpo; Dharmachakra Translation Committee, trans. (2013). Distinguishing Phenomena from Their Intrinsic Nature: Maitreya's Dharmadharmatavibhanga with Commentaries by Khenpo Shenga and Ju Mipham. Snow Lion. .
Iida, Shōtarō; Goldston, Jane, trans. (2016). Descent of Maitreya Buddha and his Enlightenment, (Taishō Volume 14, Number 454), Bukkyo Dendo Kyokai.
Mipham, Jamgon; Maitreya; Dharmachakra Translation Committee, trans. (2021). Middle Beyond Extremes: Maitreya's Madhyantavibhaga with Commentaries by Khenpo Shenga and Ju Mipham. Snow Lion. .
External links
The Maitreya Project, building a huge statue of Maitreya in Kushinagar, India
April 2010 Smithsonian Magazine Article
About the Future Buddha Ariya Ajita Metteyya
The Story of the Coming Buddha: Ariya Metteyya
The Jonang Dharma on Maitreya
Bodhisattvas
Buddhist eschatology
Sanskrit words and phrases
Messianism
Sinhalese Buddhist deities
|
```javascript
import { h } from 'preact';
import '@testing-library/jest-dom';
import { createRootFragment } from './preact-root-fragment';
describe('createRootFragment', () => {
it('has a child element as replace node', () => {
const fragment = createRootFragment(
<div className="parent" />,
<article>text</article>,
);
expect(fragment.firstChild.type).toBe('article');
});
it('handle multiple nodes', () => {
const fragment = createRootFragment(<div className="parent" />, [
<div id="app1" key="1" />,
<div id="app2" key="2" />,
]);
expect(fragment.firstChild.props.id).toBe('app1');
expect(fragment.childNodes.length).toBe(2);
});
it('adds fragment to parent context', () => {
const parent = <div className="parent" />;
const placeholder = <div className="appXYZ" />;
const fragment = createRootFragment(parent, placeholder);
expect(parent.__k.firstChild).toBe(fragment.firstChild);
expect(parent.__k.childNodes.length).toBeGreaterThan(0);
});
it('insertBefore on parent fragment', () => {
const parent = document.createElement('div');
parent.className = '#app';
const child = document.createElement('main');
const fragment = createRootFragment(parent, child);
const span = document.createElement('span');
fragment.insertBefore(span, child.parentNode);
expect(parent.children[0].tagName.toLowerCase()).toBe('span');
});
it('appendChild on parent fragment', () => {
const parent = document.createElement('div');
const fragment = createRootFragment(parent, <main id="#main" />);
const p = document.createElement('p');
fragment.appendChild(p);
expect(parent.childNodes[0].nodeName.toLowerCase()).toBe('p');
});
});
```
|
Junior Morau Kadile (born 16 December 2002) is a French professional footballer who plays as a forward for Stade Lavallois.
Club career
Kadile made his professional debut for Rennes in a Coupe de France match against Nancy 2 January 2022. The match ended in a penalty shoot-out victory for Nancy following a 1–1 draw.
On 31 January 2022, after extending his contract with Stade rennais until 2024, he was loaned to FC Famalicão in the Portuguese Primeira Liga for the rest of the season.
In June 2023, he signed a three-year contract for Stade Lavallois in French Ligue 2.
Personal life
Born in France, Kadile is of DR Congolese descent.
Career statistics
Club
References
External links
2002 births
Living people
Footballers from Rennes
French men's footballers
France men's youth international footballers
French expatriate men's footballers
French sportspeople of Democratic Republic of the Congo descent
Men's association football forwards
Stade Rennais F.C. players
Championnat National 3 players
F.C. Famalicão players
Stade Lavallois players
Primeira Liga players
Expatriate men's footballers in Portugal
Black French sportspeople
|
```objective-c
// Protocol Buffers - Google's data interchange format
// path_to_url
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Author: kenton@google.com (Kenton Varda)
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
//
// This file contains classes which describe a type of protocol message.
// You can use a message's descriptor to learn at runtime what fields
// it contains and what the types of those fields are. The Message
// interface also allows you to dynamically access and modify individual
// fields by passing the FieldDescriptor of the field you are interested
// in.
//
// Most users will not care about descriptors, because they will write
// code specific to certain protocol types and will simply use the classes
// generated by the protocol compiler directly. Advanced users who want
// to operate on arbitrary types (not known at compile time) may want to
// read descriptors in order to learn about the contents of a message.
// A very small number of users will want to construct their own
// Descriptors, either because they are implementing Message manually or
// because they are writing something like the protocol compiler.
//
// For an example of how you might use descriptors, see the code example
// at the top of message.h.
#ifndef GOOGLE_PROTOBUF_DESCRIPTOR_H__
#define GOOGLE_PROTOBUF_DESCRIPTOR_H__
#include <memory>
#ifndef _SHARED_PTR_H
#include <google/protobuf/stubs/shared_ptr.h>
#endif
#include <set>
#include <string>
#include <vector>
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/mutex.h>
#include <google/protobuf/stubs/once.h>
// TYPE_BOOL is defined in the MacOS's ConditionalMacros.h.
#ifdef TYPE_BOOL
#undef TYPE_BOOL
#endif // TYPE_BOOL
namespace google {
namespace protobuf {
// Defined in this file.
class Descriptor;
class FieldDescriptor;
class OneofDescriptor;
class EnumDescriptor;
class EnumValueDescriptor;
class ServiceDescriptor;
class MethodDescriptor;
class FileDescriptor;
class DescriptorDatabase;
class DescriptorPool;
// Defined in descriptor.proto
class DescriptorProto;
class FieldDescriptorProto;
class OneofDescriptorProto;
class EnumDescriptorProto;
class EnumValueDescriptorProto;
class ServiceDescriptorProto;
class MethodDescriptorProto;
class FileDescriptorProto;
class MessageOptions;
class FieldOptions;
class OneofOptions;
class EnumOptions;
class EnumValueOptions;
class ExtensionRangeOptions;
class ServiceOptions;
class MethodOptions;
class FileOptions;
class UninterpretedOption;
class SourceCodeInfo;
// Defined in message.h
class Message;
// Defined in descriptor.cc
class DescriptorBuilder;
class FileDescriptorTables;
struct Symbol;
// Defined in unknown_field_set.h.
class UnknownField;
// Defined in generated_message_reflection.h.
namespace internal {
class GeneratedMessageReflection;
} // namespace internal
// Defined in command_line_interface.cc
namespace compiler {
class CommandLineInterface;
} // namespace compiler
namespace descriptor_unittest {
class DescriptorTest;
} // namespace descriptor_unittest
// Defined in printer.h
namespace io {
class Printer;
} // namespace io
// NB, all indices are zero-based.
struct SourceLocation {
int start_line;
int end_line;
int start_column;
int end_column;
// Doc comments found at the source location.
// See the comments in SourceCodeInfo.Location (descriptor.proto) for details.
string leading_comments;
string trailing_comments;
std::vector<string> leading_detached_comments;
};
// Options when generating machine-parsable output from a descriptor with
// DebugString().
struct DebugStringOptions {
// include original user comments as recorded in SourceLocation entries. N.B.
// that this must be |false| by default: several other pieces of code (for
// example, the C++ code generation for fields in the proto compiler) rely on
// DebugString() output being unobstructed by user comments.
bool include_comments;
// If true, elide the braced body in the debug string.
bool elide_group_body;
bool elide_oneof_body;
DebugStringOptions()
: include_comments(false),
elide_group_body(false),
elide_oneof_body(false) {}
};
// A class to handle the simplest cases of a lazily linked descriptor
// for a message type that isn't built at the time of cross linking,
// which is needed when a pool has lazily_build_dependencies_ set.
// Must be instantiated as mutable in a descriptor.
namespace internal {
class LIBPROTOBUF_EXPORT LazyDescriptor {
public:
// Init function to be called at init time of a descriptor containing
// a LazyDescriptor.
void Init() {
descriptor_ = NULL;
name_ = NULL;
once_ = NULL;
file_ = NULL;
}
// Sets the value of the descriptor if it is known during the descriptor
// building process. Not thread safe, should only be called during the
// descriptor build process. Should not be called after SetLazy has been
// called.
void Set(const Descriptor* descriptor);
// Sets the information needed to lazily cross link the descriptor at a later
// time, SetLazy is not thread safe, should be called only once at descriptor
// build time if the symbol wasn't found and building of the file containing
// that type is delayed because lazily_build_dependencies_ is set on the pool.
// Should not be called after Set() has been called.
void SetLazy(const string& name, const FileDescriptor* file);
// Returns the current value of the descriptor, thread-safe. If SetLazy(...)
// has been called, will do a one-time cross link of the type specified,
// building the descriptor file that contains the type if necessary.
inline const Descriptor* Get() {
Once();
return descriptor_;
}
private:
static void OnceStatic(LazyDescriptor* lazy);
void OnceInternal();
void Once();
const Descriptor* descriptor_;
const string* name_;
GoogleOnceDynamic* once_;
const FileDescriptor* file_;
};
} // namespace internal
// Describes a type of protocol message, or a particular group within a
// message. To obtain the Descriptor for a given message object, call
// Message::GetDescriptor(). Generated message classes also have a
// static method called descriptor() which returns the type's descriptor.
// Use DescriptorPool to construct your own descriptors.
class LIBPROTOBUF_EXPORT Descriptor {
public:
// The name of the message type, not including its scope.
const string& name() const;
// The fully-qualified name of the message type, scope delimited by
// periods. For example, message type "Foo" which is declared in package
// "bar" has full name "bar.Foo". If a type "Baz" is nested within
// Foo, Baz's full_name is "bar.Foo.Baz". To get only the part that
// comes after the last '.', use name().
const string& full_name() const;
// Index of this descriptor within the file or containing type's message
// type array.
int index() const;
// The .proto file in which this message type was defined. Never NULL.
const FileDescriptor* file() const;
// If this Descriptor describes a nested type, this returns the type
// in which it is nested. Otherwise, returns NULL.
const Descriptor* containing_type() const;
// Get options for this message type. These are specified in the .proto file
// by placing lines like "option foo = 1234;" in the message definition.
// Allowed options are defined by MessageOptions in
// google/protobuf/descriptor.proto, and any available extensions of that
// message.
const MessageOptions& options() const;
// Write the contents of this Descriptor into the given DescriptorProto.
// The target DescriptorProto must be clear before calling this; if it
// isn't, the result may be garbage.
void CopyTo(DescriptorProto* proto) const;
// Write the contents of this decriptor in a human-readable form. Output
// will be suitable for re-parsing.
string DebugString() const;
// Similar to DebugString(), but additionally takes options (e.g.,
// include original user comments in output).
string DebugStringWithOptions(const DebugStringOptions& options) const;
// Returns true if this is a placeholder for an unknown type. This will
// only be the case if this descriptor comes from a DescriptorPool
// with AllowUnknownDependencies() set.
bool is_placeholder() const;
// Field stuff -----------------------------------------------------
// The number of fields in this message type.
int field_count() const;
// Gets a field by index, where 0 <= index < field_count().
// These are returned in the order they were defined in the .proto file.
const FieldDescriptor* field(int index) const;
// Looks up a field by declared tag number. Returns NULL if no such field
// exists.
const FieldDescriptor* FindFieldByNumber(int number) const;
// Looks up a field by name. Returns NULL if no such field exists.
const FieldDescriptor* FindFieldByName(const string& name) const;
// Looks up a field by lowercased name (as returned by lowercase_name()).
// This lookup may be ambiguous if multiple field names differ only by case,
// in which case the field returned is chosen arbitrarily from the matches.
const FieldDescriptor* FindFieldByLowercaseName(
const string& lowercase_name) const;
// Looks up a field by camel-case name (as returned by camelcase_name()).
// This lookup may be ambiguous if multiple field names differ in a way that
// leads them to have identical camel-case names, in which case the field
// returned is chosen arbitrarily from the matches.
const FieldDescriptor* FindFieldByCamelcaseName(
const string& camelcase_name) const;
// The number of oneofs in this message type.
int oneof_decl_count() const;
// Get a oneof by index, where 0 <= index < oneof_decl_count().
// These are returned in the order they were defined in the .proto file.
const OneofDescriptor* oneof_decl(int index) const;
// Looks up a oneof by name. Returns NULL if no such oneof exists.
const OneofDescriptor* FindOneofByName(const string& name) const;
// Nested type stuff -----------------------------------------------
// The number of nested types in this message type.
int nested_type_count() const;
// Gets a nested type by index, where 0 <= index < nested_type_count().
// These are returned in the order they were defined in the .proto file.
const Descriptor* nested_type(int index) const;
// Looks up a nested type by name. Returns NULL if no such nested type
// exists.
const Descriptor* FindNestedTypeByName(const string& name) const;
// Enum stuff ------------------------------------------------------
// The number of enum types in this message type.
int enum_type_count() const;
// Gets an enum type by index, where 0 <= index < enum_type_count().
// These are returned in the order they were defined in the .proto file.
const EnumDescriptor* enum_type(int index) const;
// Looks up an enum type by name. Returns NULL if no such enum type exists.
const EnumDescriptor* FindEnumTypeByName(const string& name) const;
// Looks up an enum value by name, among all enum types in this message.
// Returns NULL if no such value exists.
const EnumValueDescriptor* FindEnumValueByName(const string& name) const;
// Extensions ------------------------------------------------------
// A range of field numbers which are designated for third-party
// extensions.
struct ExtensionRange {
typedef ExtensionRangeOptions OptionsType;
int start; // inclusive
int end; // exclusive
const ExtensionRangeOptions* options_;
};
// The number of extension ranges in this message type.
int extension_range_count() const;
// Gets an extension range by index, where 0 <= index <
// extension_range_count(). These are returned in the order they were defined
// in the .proto file.
const ExtensionRange* extension_range(int index) const;
// Returns true if the number is in one of the extension ranges.
bool IsExtensionNumber(int number) const;
// Returns NULL if no extension range contains the given number.
const ExtensionRange* FindExtensionRangeContainingNumber(int number) const;
// The number of extensions -- extending *other* messages -- that were
// defined nested within this message type's scope.
int extension_count() const;
// Get an extension by index, where 0 <= index < extension_count().
// These are returned in the order they were defined in the .proto file.
const FieldDescriptor* extension(int index) const;
// Looks up a named extension (which extends some *other* message type)
// defined within this message type's scope.
const FieldDescriptor* FindExtensionByName(const string& name) const;
// Similar to FindFieldByLowercaseName(), but finds extensions defined within
// this message type's scope.
const FieldDescriptor* FindExtensionByLowercaseName(const string& name) const;
// Similar to FindFieldByCamelcaseName(), but finds extensions defined within
// this message type's scope.
const FieldDescriptor* FindExtensionByCamelcaseName(const string& name) const;
// Reserved fields -------------------------------------------------
// A range of reserved field numbers.
struct ReservedRange {
int start; // inclusive
int end; // exclusive
};
// The number of reserved ranges in this message type.
int reserved_range_count() const;
// Gets an reserved range by index, where 0 <= index <
// reserved_range_count(). These are returned in the order they were defined
// in the .proto file.
const ReservedRange* reserved_range(int index) const;
// Returns true if the number is in one of the reserved ranges.
bool IsReservedNumber(int number) const;
// Returns NULL if no reserved range contains the given number.
const ReservedRange* FindReservedRangeContainingNumber(int number) const;
// The number of reserved field names in this message type.
int reserved_name_count() const;
// Gets a reserved name by index, where 0 <= index < reserved_name_count().
const string& reserved_name(int index) const;
// Returns true if the field name is reserved.
bool IsReservedName(const string& name) const;
// Source Location ---------------------------------------------------
// Updates |*out_location| to the source location of the complete
// extent of this message declaration. Returns false and leaves
// |*out_location| unchanged iff location information was not available.
bool GetSourceLocation(SourceLocation* out_location) const;
private:
typedef MessageOptions OptionsType;
// Allows tests to test CopyTo(proto, true).
friend class ::google::protobuf::descriptor_unittest::DescriptorTest;
// Allows access to GetLocationPath for annotations.
friend class ::google::protobuf::io::Printer;
// Fill the json_name field of FieldDescriptorProto.
void CopyJsonNameTo(DescriptorProto* proto) const;
// Internal version of DebugString; controls the level of indenting for
// correct depth. Takes |options| to control debug-string options, and
// |include_opening_clause| to indicate whether the "message ... " part of the
// clause has already been generated (this varies depending on context).
void DebugString(int depth, string *contents,
const DebugStringOptions& options,
bool include_opening_clause) const;
// Walks up the descriptor tree to generate the source location path
// to this descriptor from the file root.
void GetLocationPath(std::vector<int>* output) const;
const string* name_;
const string* full_name_;
const FileDescriptor* file_;
const Descriptor* containing_type_;
const MessageOptions* options_;
// These arrays are separated from their sizes to minimize padding on 64-bit.
FieldDescriptor* fields_;
OneofDescriptor* oneof_decls_;
Descriptor* nested_types_;
EnumDescriptor* enum_types_;
ExtensionRange* extension_ranges_;
FieldDescriptor* extensions_;
ReservedRange* reserved_ranges_;
const string** reserved_names_;
int field_count_;
int oneof_decl_count_;
int nested_type_count_;
int enum_type_count_;
int extension_range_count_;
int extension_count_;
int reserved_range_count_;
int reserved_name_count_;
// True if this is a placeholder for an unknown type.
bool is_placeholder_;
// True if this is a placeholder and the type name wasn't fully-qualified.
bool is_unqualified_placeholder_;
// IMPORTANT: If you add a new field, make sure to search for all instances
// of Allocate<Descriptor>() and AllocateArray<Descriptor>() in descriptor.cc
// and update them to initialize the field.
// Must be constructed using DescriptorPool.
Descriptor() {}
friend class DescriptorBuilder;
friend class DescriptorPool;
friend class EnumDescriptor;
friend class FieldDescriptor;
friend class OneofDescriptor;
friend class MethodDescriptor;
friend class FileDescriptor;
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Descriptor);
};
// Describes a single field of a message. To get the descriptor for a given
// field, first get the Descriptor for the message in which it is defined,
// then call Descriptor::FindFieldByName(). To get a FieldDescriptor for
// an extension, do one of the following:
// - Get the Descriptor or FileDescriptor for its containing scope, then
// call Descriptor::FindExtensionByName() or
// FileDescriptor::FindExtensionByName().
// - Given a DescriptorPool, call DescriptorPool::FindExtensionByNumber().
// - Given a Reflection for a message object, call
// Reflection::FindKnownExtensionByName() or
// Reflection::FindKnownExtensionByNumber().
// Use DescriptorPool to construct your own descriptors.
class LIBPROTOBUF_EXPORT FieldDescriptor {
public:
// Identifies a field type. 0 is reserved for errors. The order is weird
// for historical reasons. Types 12 and up are new in proto2.
enum Type {
TYPE_DOUBLE = 1, // double, exactly eight bytes on the wire.
TYPE_FLOAT = 2, // float, exactly four bytes on the wire.
TYPE_INT64 = 3, // int64, varint on the wire. Negative numbers
// take 10 bytes. Use TYPE_SINT64 if negative
// values are likely.
TYPE_UINT64 = 4, // uint64, varint on the wire.
TYPE_INT32 = 5, // int32, varint on the wire. Negative numbers
// take 10 bytes. Use TYPE_SINT32 if negative
// values are likely.
TYPE_FIXED64 = 6, // uint64, exactly eight bytes on the wire.
TYPE_FIXED32 = 7, // uint32, exactly four bytes on the wire.
TYPE_BOOL = 8, // bool, varint on the wire.
TYPE_STRING = 9, // UTF-8 text.
TYPE_GROUP = 10, // Tag-delimited message. Deprecated.
TYPE_MESSAGE = 11, // Length-delimited message.
TYPE_BYTES = 12, // Arbitrary byte array.
TYPE_UINT32 = 13, // uint32, varint on the wire
TYPE_ENUM = 14, // Enum, varint on the wire
TYPE_SFIXED32 = 15, // int32, exactly four bytes on the wire
TYPE_SFIXED64 = 16, // int64, exactly eight bytes on the wire
TYPE_SINT32 = 17, // int32, ZigZag-encoded varint on the wire
TYPE_SINT64 = 18, // int64, ZigZag-encoded varint on the wire
MAX_TYPE = 18, // Constant useful for defining lookup tables
// indexed by Type.
};
// Specifies the C++ data type used to represent the field. There is a
// fixed mapping from Type to CppType where each Type maps to exactly one
// CppType. 0 is reserved for errors.
enum CppType {
CPPTYPE_INT32 = 1, // TYPE_INT32, TYPE_SINT32, TYPE_SFIXED32
CPPTYPE_INT64 = 2, // TYPE_INT64, TYPE_SINT64, TYPE_SFIXED64
CPPTYPE_UINT32 = 3, // TYPE_UINT32, TYPE_FIXED32
CPPTYPE_UINT64 = 4, // TYPE_UINT64, TYPE_FIXED64
CPPTYPE_DOUBLE = 5, // TYPE_DOUBLE
CPPTYPE_FLOAT = 6, // TYPE_FLOAT
CPPTYPE_BOOL = 7, // TYPE_BOOL
CPPTYPE_ENUM = 8, // TYPE_ENUM
CPPTYPE_STRING = 9, // TYPE_STRING, TYPE_BYTES
CPPTYPE_MESSAGE = 10, // TYPE_MESSAGE, TYPE_GROUP
MAX_CPPTYPE = 10, // Constant useful for defining lookup tables
// indexed by CppType.
};
// Identifies whether the field is optional, required, or repeated. 0 is
// reserved for errors.
enum Label {
LABEL_OPTIONAL = 1, // optional
LABEL_REQUIRED = 2, // required
LABEL_REPEATED = 3, // repeated
MAX_LABEL = 3, // Constant useful for defining lookup tables
// indexed by Label.
};
// Valid field numbers are positive integers up to kMaxNumber.
static const int kMaxNumber = (1 << 29) - 1;
// First field number reserved for the protocol buffer library implementation.
// Users may not declare fields that use reserved numbers.
static const int kFirstReservedNumber = 19000;
// Last field number reserved for the protocol buffer library implementation.
// Users may not declare fields that use reserved numbers.
static const int kLastReservedNumber = 19999;
const string& name() const; // Name of this field within the message.
const string& full_name() const; // Fully-qualified name of the field.
const string& json_name() const; // JSON name of this field.
const FileDescriptor* file() const;// File in which this field was defined.
bool is_extension() const; // Is this an extension field?
int number() const; // Declared tag number.
// Same as name() except converted to lower-case. This (and especially the
// FindFieldByLowercaseName() method) can be useful when parsing formats
// which prefer to use lowercase naming style. (Although, technically
// field names should be lowercased anyway according to the protobuf style
// guide, so this only makes a difference when dealing with old .proto files
// which do not follow the guide.)
const string& lowercase_name() const;
// Same as name() except converted to camel-case. In this conversion, any
// time an underscore appears in the name, it is removed and the next
// letter is capitalized. Furthermore, the first letter of the name is
// lower-cased. Examples:
// FooBar -> fooBar
// foo_bar -> fooBar
// fooBar -> fooBar
// This (and especially the FindFieldByCamelcaseName() method) can be useful
// when parsing formats which prefer to use camel-case naming style.
const string& camelcase_name() const;
Type type() const; // Declared type of this field.
const char* type_name() const; // Name of the declared type.
CppType cpp_type() const; // C++ type of this field.
const char* cpp_type_name() const; // Name of the C++ type.
Label label() const; // optional/required/repeated
bool is_required() const; // shorthand for label() == LABEL_REQUIRED
bool is_optional() const; // shorthand for label() == LABEL_OPTIONAL
bool is_repeated() const; // shorthand for label() == LABEL_REPEATED
bool is_packable() const; // shorthand for is_repeated() &&
// IsTypePackable(type())
bool is_packed() const; // shorthand for is_packable() &&
// options().packed()
bool is_map() const; // shorthand for type() == TYPE_MESSAGE &&
// message_type()->options().map_entry()
// Index of this field within the message's field array, or the file or
// extension scope's extensions array.
int index() const;
// Does this field have an explicitly-declared default value?
bool has_default_value() const;
// Whether the user has specified the json_name field option in the .proto
// file.
bool has_json_name() const;
// Get the field default value if cpp_type() == CPPTYPE_INT32. If no
// explicit default was defined, the default is 0.
int32 default_value_int32() const;
// Get the field default value if cpp_type() == CPPTYPE_INT64. If no
// explicit default was defined, the default is 0.
int64 default_value_int64() const;
// Get the field default value if cpp_type() == CPPTYPE_UINT32. If no
// explicit default was defined, the default is 0.
uint32 default_value_uint32() const;
// Get the field default value if cpp_type() == CPPTYPE_UINT64. If no
// explicit default was defined, the default is 0.
uint64 default_value_uint64() const;
// Get the field default value if cpp_type() == CPPTYPE_FLOAT. If no
// explicit default was defined, the default is 0.0.
float default_value_float() const;
// Get the field default value if cpp_type() == CPPTYPE_DOUBLE. If no
// explicit default was defined, the default is 0.0.
double default_value_double() const;
// Get the field default value if cpp_type() == CPPTYPE_BOOL. If no
// explicit default was defined, the default is false.
bool default_value_bool() const;
// Get the field default value if cpp_type() == CPPTYPE_ENUM. If no
// explicit default was defined, the default is the first value defined
// in the enum type (all enum types are required to have at least one value).
// This never returns NULL.
const EnumValueDescriptor* default_value_enum() const;
// Get the field default value if cpp_type() == CPPTYPE_STRING. If no
// explicit default was defined, the default is the empty string.
const string& default_value_string() const;
// The Descriptor for the message of which this is a field. For extensions,
// this is the extended type. Never NULL.
const Descriptor* containing_type() const;
// If the field is a member of a oneof, this is the one, otherwise this is
// NULL.
const OneofDescriptor* containing_oneof() const;
// If the field is a member of a oneof, returns the index in that oneof.
int index_in_oneof() const;
// An extension may be declared within the scope of another message. If this
// field is an extension (is_extension() is true), then extension_scope()
// returns that message, or NULL if the extension was declared at global
// scope. If this is not an extension, extension_scope() is undefined (may
// assert-fail).
const Descriptor* extension_scope() const;
// If type is TYPE_MESSAGE or TYPE_GROUP, returns a descriptor for the
// message or the group type. Otherwise, returns null.
const Descriptor* message_type() const;
// If type is TYPE_ENUM, returns a descriptor for the enum. Otherwise,
// returns null.
const EnumDescriptor* enum_type() const;
// Get the FieldOptions for this field. This includes things listed in
// square brackets after the field definition. E.g., the field:
// optional string text = 1 [ctype=CORD];
// has the "ctype" option set. Allowed options are defined by FieldOptions
// in google/protobuf/descriptor.proto, and any available extensions of that
// message.
const FieldOptions& options() const;
// See Descriptor::CopyTo().
void CopyTo(FieldDescriptorProto* proto) const;
// See Descriptor::DebugString().
string DebugString() const;
// See Descriptor::DebugStringWithOptions().
string DebugStringWithOptions(const DebugStringOptions& options) const;
// Helper method to get the CppType for a particular Type.
static CppType TypeToCppType(Type type);
// Helper method to get the name of a Type.
static const char* TypeName(Type type);
// Helper method to get the name of a CppType.
static const char* CppTypeName(CppType cpp_type);
// Return true iff [packed = true] is valid for fields of this type.
static inline bool IsTypePackable(Type field_type);
// Source Location ---------------------------------------------------
// Updates |*out_location| to the source location of the complete
// extent of this field declaration. Returns false and leaves
// |*out_location| unchanged iff location information was not available.
bool GetSourceLocation(SourceLocation* out_location) const;
private:
typedef FieldOptions OptionsType;
// Allows access to GetLocationPath for annotations.
friend class ::google::protobuf::io::Printer;
// Fill the json_name field of FieldDescriptorProto.
void CopyJsonNameTo(FieldDescriptorProto* proto) const;
// See Descriptor::DebugString().
enum PrintLabelFlag { PRINT_LABEL, OMIT_LABEL };
void DebugString(int depth, PrintLabelFlag print_label_flag,
string* contents, const DebugStringOptions& options) const;
// formats the default value appropriately and returns it as a string.
// Must have a default value to call this. If quote_string_type is true, then
// types of CPPTYPE_STRING whill be surrounded by quotes and CEscaped.
string DefaultValueAsString(bool quote_string_type) const;
// Helper function that returns the field type name for DebugString.
string FieldTypeNameDebugString() const;
// Walks up the descriptor tree to generate the source location path
// to this descriptor from the file root.
void GetLocationPath(std::vector<int>* output) const;
// Returns true if this is a map message type.
bool is_map_message_type() const;
const string* name_;
const string* full_name_;
const string* lowercase_name_;
const string* camelcase_name_;
// If has_json_name_ is true, it's the value specified by the user.
// Otherwise, it has the same value as camelcase_name_.
const string* json_name_;
const FileDescriptor* file_;
GoogleOnceDynamic* type_once_;
static void TypeOnceInit(const FieldDescriptor* to_init);
void InternalTypeOnceInit() const;
mutable Type type_;
Label label_;
bool has_default_value_;
// Whether the user has specified the json_name field option in the .proto
// file.
bool has_json_name_;
bool is_extension_;
int number_;
int index_in_oneof_;
const Descriptor* containing_type_;
const OneofDescriptor* containing_oneof_;
const Descriptor* extension_scope_;
mutable const Descriptor* message_type_;
mutable const EnumDescriptor* enum_type_;
const FieldOptions* options_;
const string* type_name_;
const string* default_value_enum_name_;
// IMPORTANT: If you add a new field, make sure to search for all instances
// of Allocate<FieldDescriptor>() and AllocateArray<FieldDescriptor>() in
// descriptor.cc and update them to initialize the field.
union {
int32 default_value_int32_;
int64 default_value_int64_;
uint32 default_value_uint32_;
uint64 default_value_uint64_;
float default_value_float_;
double default_value_double_;
bool default_value_bool_;
mutable const EnumValueDescriptor* default_value_enum_;
const string* default_value_string_;
};
static const CppType kTypeToCppTypeMap[MAX_TYPE + 1];
static const char * const kTypeToName[MAX_TYPE + 1];
static const char * const kCppTypeToName[MAX_CPPTYPE + 1];
static const char * const kLabelToName[MAX_LABEL + 1];
// Must be constructed using DescriptorPool.
FieldDescriptor() {}
friend class DescriptorBuilder;
friend class FileDescriptor;
friend class Descriptor;
friend class OneofDescriptor;
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FieldDescriptor);
};
// Describes a oneof defined in a message type.
class LIBPROTOBUF_EXPORT OneofDescriptor {
public:
const string& name() const; // Name of this oneof.
const string& full_name() const; // Fully-qualified name of the oneof.
// Index of this oneof within the message's oneof array.
int index() const;
// The .proto file in which this oneof was defined. Never NULL.
const FileDescriptor* file() const;
// The Descriptor for the message containing this oneof.
const Descriptor* containing_type() const;
// The number of (non-extension) fields which are members of this oneof.
int field_count() const;
// Get a member of this oneof, in the order in which they were declared in the
// .proto file. Does not include extensions.
const FieldDescriptor* field(int index) const;
const OneofOptions& options() const;
// See Descriptor::CopyTo().
void CopyTo(OneofDescriptorProto* proto) const;
// See Descriptor::DebugString().
string DebugString() const;
// See Descriptor::DebugStringWithOptions().
string DebugStringWithOptions(const DebugStringOptions& options) const;
// Source Location ---------------------------------------------------
// Updates |*out_location| to the source location of the complete
// extent of this oneof declaration. Returns false and leaves
// |*out_location| unchanged iff location information was not available.
bool GetSourceLocation(SourceLocation* out_location) const;
private:
typedef OneofOptions OptionsType;
// Allows access to GetLocationPath for annotations.
friend class ::google::protobuf::io::Printer;
// See Descriptor::DebugString().
void DebugString(int depth, string* contents,
const DebugStringOptions& options) const;
// Walks up the descriptor tree to generate the source location path
// to this descriptor from the file root.
void GetLocationPath(std::vector<int>* output) const;
const string* name_;
const string* full_name_;
const Descriptor* containing_type_;
bool is_extendable_;
int field_count_;
const FieldDescriptor** fields_;
const OneofOptions* options_;
// IMPORTANT: If you add a new field, make sure to search for all instances
// of Allocate<OneofDescriptor>() and AllocateArray<OneofDescriptor>()
// in descriptor.cc and update them to initialize the field.
// Must be constructed using DescriptorPool.
OneofDescriptor() {}
friend class DescriptorBuilder;
friend class Descriptor;
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(OneofDescriptor);
};
// Describes an enum type defined in a .proto file. To get the EnumDescriptor
// for a generated enum type, call TypeName_descriptor(). Use DescriptorPool
// to construct your own descriptors.
class LIBPROTOBUF_EXPORT EnumDescriptor {
public:
// The name of this enum type in the containing scope.
const string& name() const;
// The fully-qualified name of the enum type, scope delimited by periods.
const string& full_name() const;
// Index of this enum within the file or containing message's enum array.
int index() const;
// The .proto file in which this enum type was defined. Never NULL.
const FileDescriptor* file() const;
// The number of values for this EnumDescriptor. Guaranteed to be greater
// than zero.
int value_count() const;
// Gets a value by index, where 0 <= index < value_count().
// These are returned in the order they were defined in the .proto file.
const EnumValueDescriptor* value(int index) const;
// Looks up a value by name. Returns NULL if no such value exists.
const EnumValueDescriptor* FindValueByName(const string& name) const;
// Looks up a value by number. Returns NULL if no such value exists. If
// multiple values have this number, the first one defined is returned.
const EnumValueDescriptor* FindValueByNumber(int number) const;
// If this enum type is nested in a message type, this is that message type.
// Otherwise, NULL.
const Descriptor* containing_type() const;
// Get options for this enum type. These are specified in the .proto file by
// placing lines like "option foo = 1234;" in the enum definition. Allowed
// options are defined by EnumOptions in google/protobuf/descriptor.proto,
// and any available extensions of that message.
const EnumOptions& options() const;
// See Descriptor::CopyTo().
void CopyTo(EnumDescriptorProto* proto) const;
// See Descriptor::DebugString().
string DebugString() const;
// See Descriptor::DebugStringWithOptions().
string DebugStringWithOptions(const DebugStringOptions& options) const;
// Returns true if this is a placeholder for an unknown enum. This will
// only be the case if this descriptor comes from a DescriptorPool
// with AllowUnknownDependencies() set.
bool is_placeholder() const;
// Reserved fields -------------------------------------------------
// A range of reserved field numbers.
struct ReservedRange {
int start; // inclusive
int end; // inclusive
};
// The number of reserved ranges in this message type.
int reserved_range_count() const;
// Gets an reserved range by index, where 0 <= index <
// reserved_range_count(). These are returned in the order they were defined
// in the .proto file.
const EnumDescriptor::ReservedRange* reserved_range(int index) const;
// Returns true if the number is in one of the reserved ranges.
bool IsReservedNumber(int number) const;
// Returns NULL if no reserved range contains the given number.
const EnumDescriptor::ReservedRange*
FindReservedRangeContainingNumber(int number) const;
// The number of reserved field names in this message type.
int reserved_name_count() const;
// Gets a reserved name by index, where 0 <= index < reserved_name_count().
const string& reserved_name(int index) const;
// Returns true if the field name is reserved.
bool IsReservedName(const string& name) const;
// Source Location ---------------------------------------------------
// Updates |*out_location| to the source location of the complete
// extent of this enum declaration. Returns false and leaves
// |*out_location| unchanged iff location information was not available.
bool GetSourceLocation(SourceLocation* out_location) const;
private:
typedef EnumOptions OptionsType;
// Allows access to GetLocationPath for annotations.
friend class ::google::protobuf::io::Printer;
// Looks up a value by number. If the value does not exist, dynamically
// creates a new EnumValueDescriptor for that value, assuming that it was
// unknown. If a new descriptor is created, this is done in a thread-safe way,
// and future calls will return the same value descriptor pointer.
//
// This is private but is used by GeneratedMessageReflection (which is
// friended below) to return a valid EnumValueDescriptor from GetEnum() when
// this feature is enabled.
const EnumValueDescriptor*
FindValueByNumberCreatingIfUnknown(int number) const;
// See Descriptor::DebugString().
void DebugString(int depth, string *contents,
const DebugStringOptions& options) const;
// Walks up the descriptor tree to generate the source location path
// to this descriptor from the file root.
void GetLocationPath(std::vector<int>* output) const;
const string* name_;
const string* full_name_;
const FileDescriptor* file_;
const Descriptor* containing_type_;
const EnumOptions* options_;
// True if this is a placeholder for an unknown type.
bool is_placeholder_;
// True if this is a placeholder and the type name wasn't fully-qualified.
bool is_unqualified_placeholder_;
int value_count_;
EnumValueDescriptor* values_;
int reserved_range_count_;
int reserved_name_count_;
EnumDescriptor::ReservedRange* reserved_ranges_;
const string** reserved_names_;
// IMPORTANT: If you add a new field, make sure to search for all instances
// of Allocate<EnumDescriptor>() and AllocateArray<EnumDescriptor>() in
// descriptor.cc and update them to initialize the field.
// Must be constructed using DescriptorPool.
EnumDescriptor() {}
friend class DescriptorBuilder;
friend class Descriptor;
friend class FieldDescriptor;
friend class EnumValueDescriptor;
friend class FileDescriptor;
friend class DescriptorPool;
friend class internal::GeneratedMessageReflection;
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(EnumDescriptor);
};
// Describes an individual enum constant of a particular type. To get the
// EnumValueDescriptor for a given enum value, first get the EnumDescriptor
// for its type, then use EnumDescriptor::FindValueByName() or
// EnumDescriptor::FindValueByNumber(). Use DescriptorPool to construct
// your own descriptors.
class LIBPROTOBUF_EXPORT EnumValueDescriptor {
public:
const string& name() const; // Name of this enum constant.
int index() const; // Index within the enums's Descriptor.
int number() const; // Numeric value of this enum constant.
// The full_name of an enum value is a sibling symbol of the enum type.
// e.g. the full name of FieldDescriptorProto::TYPE_INT32 is actually
// "google.protobuf.FieldDescriptorProto.TYPE_INT32", NOT
// "google.protobuf.FieldDescriptorProto.Type.TYPE_INT32". This is to conform
// with C++ scoping rules for enums.
const string& full_name() const;
// The .proto file in which this value was defined. Never NULL.
const FileDescriptor* file() const;
// The type of this value. Never NULL.
const EnumDescriptor* type() const;
// Get options for this enum value. These are specified in the .proto file
// by adding text like "[foo = 1234]" after an enum value definition.
// Allowed options are defined by EnumValueOptions in
// google/protobuf/descriptor.proto, and any available extensions of that
// message.
const EnumValueOptions& options() const;
// See Descriptor::CopyTo().
void CopyTo(EnumValueDescriptorProto* proto) const;
// See Descriptor::DebugString().
string DebugString() const;
// See Descriptor::DebugStringWithOptions().
string DebugStringWithOptions(const DebugStringOptions& options) const;
// Source Location ---------------------------------------------------
// Updates |*out_location| to the source location of the complete
// extent of this enum value declaration. Returns false and leaves
// |*out_location| unchanged iff location information was not available.
bool GetSourceLocation(SourceLocation* out_location) const;
private:
typedef EnumValueOptions OptionsType;
// Allows access to GetLocationPath for annotations.
friend class ::google::protobuf::io::Printer;
// See Descriptor::DebugString().
void DebugString(int depth, string *contents,
const DebugStringOptions& options) const;
// Walks up the descriptor tree to generate the source location path
// to this descriptor from the file root.
void GetLocationPath(std::vector<int>* output) const;
const string* name_;
const string* full_name_;
int number_;
const EnumDescriptor* type_;
const EnumValueOptions* options_;
// IMPORTANT: If you add a new field, make sure to search for all instances
// of Allocate<EnumValueDescriptor>() and AllocateArray<EnumValueDescriptor>()
// in descriptor.cc and update them to initialize the field.
// Must be constructed using DescriptorPool.
EnumValueDescriptor() {}
friend class DescriptorBuilder;
friend class EnumDescriptor;
friend class DescriptorPool;
friend class FileDescriptorTables;
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(EnumValueDescriptor);
};
// Describes an RPC service. To get the ServiceDescriptor for a service,
// call Service::GetDescriptor(). Generated service classes also have a
// static method called descriptor() which returns the type's
// ServiceDescriptor. Use DescriptorPool to construct your own descriptors.
class LIBPROTOBUF_EXPORT ServiceDescriptor {
public:
// The name of the service, not including its containing scope.
const string& name() const;
// The fully-qualified name of the service, scope delimited by periods.
const string& full_name() const;
// Index of this service within the file's services array.
int index() const;
// The .proto file in which this service was defined. Never NULL.
const FileDescriptor* file() const;
// Get options for this service type. These are specified in the .proto file
// by placing lines like "option foo = 1234;" in the service definition.
// Allowed options are defined by ServiceOptions in
// google/protobuf/descriptor.proto, and any available extensions of that
// message.
const ServiceOptions& options() const;
// The number of methods this service defines.
int method_count() const;
// Gets a MethodDescriptor by index, where 0 <= index < method_count().
// These are returned in the order they were defined in the .proto file.
const MethodDescriptor* method(int index) const;
// Look up a MethodDescriptor by name.
const MethodDescriptor* FindMethodByName(const string& name) const;
// See Descriptor::CopyTo().
void CopyTo(ServiceDescriptorProto* proto) const;
// See Descriptor::DebugString().
string DebugString() const;
// See Descriptor::DebugStringWithOptions().
string DebugStringWithOptions(const DebugStringOptions& options) const;
// Source Location ---------------------------------------------------
// Updates |*out_location| to the source location of the complete
// extent of this service declaration. Returns false and leaves
// |*out_location| unchanged iff location information was not available.
bool GetSourceLocation(SourceLocation* out_location) const;
private:
typedef ServiceOptions OptionsType;
// Allows access to GetLocationPath for annotations.
friend class ::google::protobuf::io::Printer;
// See Descriptor::DebugString().
void DebugString(string *contents, const DebugStringOptions& options) const;
// Walks up the descriptor tree to generate the source location path
// to this descriptor from the file root.
void GetLocationPath(std::vector<int>* output) const;
const string* name_;
const string* full_name_;
const FileDescriptor* file_;
const ServiceOptions* options_;
MethodDescriptor* methods_;
int method_count_;
// IMPORTANT: If you add a new field, make sure to search for all instances
// of Allocate<ServiceDescriptor>() and AllocateArray<ServiceDescriptor>() in
// descriptor.cc and update them to initialize the field.
// Must be constructed using DescriptorPool.
ServiceDescriptor() {}
friend class DescriptorBuilder;
friend class FileDescriptor;
friend class MethodDescriptor;
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ServiceDescriptor);
};
// Describes an individual service method. To obtain a MethodDescriptor given
// a service, first get its ServiceDescriptor, then call
// ServiceDescriptor::FindMethodByName(). Use DescriptorPool to construct your
// own descriptors.
class LIBPROTOBUF_EXPORT MethodDescriptor {
public:
// Name of this method, not including containing scope.
const string& name() const;
// The fully-qualified name of the method, scope delimited by periods.
const string& full_name() const;
// Index within the service's Descriptor.
int index() const;
// The .proto file in which this method was defined. Never NULL.
const FileDescriptor* file() const;
// Gets the service to which this method belongs. Never NULL.
const ServiceDescriptor* service() const;
// Gets the type of protocol message which this method accepts as input.
const Descriptor* input_type() const;
// Gets the type of protocol message which this message produces as output.
const Descriptor* output_type() const;
// Gets whether the client streams multiple requests.
bool client_streaming() const;
// Gets whether the server streams multiple responses.
bool server_streaming() const;
// Get options for this method. These are specified in the .proto file by
// placing lines like "option foo = 1234;" in curly-braces after a method
// declaration. Allowed options are defined by MethodOptions in
// google/protobuf/descriptor.proto, and any available extensions of that
// message.
const MethodOptions& options() const;
// See Descriptor::CopyTo().
void CopyTo(MethodDescriptorProto* proto) const;
// See Descriptor::DebugString().
string DebugString() const;
// See Descriptor::DebugStringWithOptions().
string DebugStringWithOptions(const DebugStringOptions& options) const;
// Source Location ---------------------------------------------------
// Updates |*out_location| to the source location of the complete
// extent of this method declaration. Returns false and leaves
// |*out_location| unchanged iff location information was not available.
bool GetSourceLocation(SourceLocation* out_location) const;
private:
typedef MethodOptions OptionsType;
// Allows access to GetLocationPath for annotations.
friend class ::google::protobuf::io::Printer;
// See Descriptor::DebugString().
void DebugString(int depth, string *contents,
const DebugStringOptions& options) const;
// Walks up the descriptor tree to generate the source location path
// to this descriptor from the file root.
void GetLocationPath(std::vector<int>* output) const;
const string* name_;
const string* full_name_;
const ServiceDescriptor* service_;
mutable internal::LazyDescriptor input_type_;
mutable internal::LazyDescriptor output_type_;
const MethodOptions* options_;
bool client_streaming_;
bool server_streaming_;
// IMPORTANT: If you add a new field, make sure to search for all instances
// of Allocate<MethodDescriptor>() and AllocateArray<MethodDescriptor>() in
// descriptor.cc and update them to initialize the field.
// Must be constructed using DescriptorPool.
MethodDescriptor() {}
friend class DescriptorBuilder;
friend class ServiceDescriptor;
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MethodDescriptor);
};
// Describes a whole .proto file. To get the FileDescriptor for a compiled-in
// file, get the descriptor for something defined in that file and call
// descriptor->file(). Use DescriptorPool to construct your own descriptors.
class LIBPROTOBUF_EXPORT FileDescriptor {
public:
// The filename, relative to the source tree.
// e.g. "google/protobuf/descriptor.proto"
const string& name() const;
// The package, e.g. "google.protobuf.compiler".
const string& package() const;
// The DescriptorPool in which this FileDescriptor and all its contents were
// allocated. Never NULL.
const DescriptorPool* pool() const;
// The number of files imported by this one.
int dependency_count() const;
// Gets an imported file by index, where 0 <= index < dependency_count().
// These are returned in the order they were defined in the .proto file.
const FileDescriptor* dependency(int index) const;
// The number of files public imported by this one.
// The public dependency list is a subset of the dependency list.
int public_dependency_count() const;
// Gets a public imported file by index, where 0 <= index <
// public_dependency_count().
// These are returned in the order they were defined in the .proto file.
const FileDescriptor* public_dependency(int index) const;
// The number of files that are imported for weak fields.
// The weak dependency list is a subset of the dependency list.
int weak_dependency_count() const;
// Gets a weak imported file by index, where 0 <= index <
// weak_dependency_count().
// These are returned in the order they were defined in the .proto file.
const FileDescriptor* weak_dependency(int index) const;
// Number of top-level message types defined in this file. (This does not
// include nested types.)
int message_type_count() const;
// Gets a top-level message type, where 0 <= index < message_type_count().
// These are returned in the order they were defined in the .proto file.
const Descriptor* message_type(int index) const;
// Number of top-level enum types defined in this file. (This does not
// include nested types.)
int enum_type_count() const;
// Gets a top-level enum type, where 0 <= index < enum_type_count().
// These are returned in the order they were defined in the .proto file.
const EnumDescriptor* enum_type(int index) const;
// Number of services defined in this file.
int service_count() const;
// Gets a service, where 0 <= index < service_count().
// These are returned in the order they were defined in the .proto file.
const ServiceDescriptor* service(int index) const;
// Number of extensions defined at file scope. (This does not include
// extensions nested within message types.)
int extension_count() const;
// Gets an extension's descriptor, where 0 <= index < extension_count().
// These are returned in the order they were defined in the .proto file.
const FieldDescriptor* extension(int index) const;
// Get options for this file. These are specified in the .proto file by
// placing lines like "option foo = 1234;" at the top level, outside of any
// other definitions. Allowed options are defined by FileOptions in
// google/protobuf/descriptor.proto, and any available extensions of that
// message.
const FileOptions& options() const;
// Syntax of this file.
enum Syntax {
SYNTAX_UNKNOWN = 0,
SYNTAX_PROTO2 = 2,
SYNTAX_PROTO3 = 3,
};
Syntax syntax() const;
static const char* SyntaxName(Syntax syntax);
// Find a top-level message type by name. Returns NULL if not found.
const Descriptor* FindMessageTypeByName(const string& name) const;
// Find a top-level enum type by name. Returns NULL if not found.
const EnumDescriptor* FindEnumTypeByName(const string& name) const;
// Find an enum value defined in any top-level enum by name. Returns NULL if
// not found.
const EnumValueDescriptor* FindEnumValueByName(const string& name) const;
// Find a service definition by name. Returns NULL if not found.
const ServiceDescriptor* FindServiceByName(const string& name) const;
// Find a top-level extension definition by name. Returns NULL if not found.
const FieldDescriptor* FindExtensionByName(const string& name) const;
// Similar to FindExtensionByName(), but searches by lowercased-name. See
// Descriptor::FindFieldByLowercaseName().
const FieldDescriptor* FindExtensionByLowercaseName(const string& name) const;
// Similar to FindExtensionByName(), but searches by camelcased-name. See
// Descriptor::FindFieldByCamelcaseName().
const FieldDescriptor* FindExtensionByCamelcaseName(const string& name) const;
// See Descriptor::CopyTo().
// Notes:
// - This method does NOT copy source code information since it is relatively
// large and rarely needed. See CopySourceCodeInfoTo() below.
void CopyTo(FileDescriptorProto* proto) const;
// Write the source code information of this FileDescriptor into the given
// FileDescriptorProto. See CopyTo() above.
void CopySourceCodeInfoTo(FileDescriptorProto* proto) const;
// Fill the json_name field of FieldDescriptorProto for all fields. Can only
// be called after CopyTo().
void CopyJsonNameTo(FileDescriptorProto* proto) const;
// See Descriptor::DebugString().
string DebugString() const;
// See Descriptor::DebugStringWithOptions().
string DebugStringWithOptions(const DebugStringOptions& options) const;
// Returns true if this is a placeholder for an unknown file. This will
// only be the case if this descriptor comes from a DescriptorPool
// with AllowUnknownDependencies() set.
bool is_placeholder() const;
// Updates |*out_location| to the source location of the complete extent of
// this file declaration (namely, the empty path).
bool GetSourceLocation(SourceLocation* out_location) const;
// Updates |*out_location| to the source location of the complete
// extent of the declaration or declaration-part denoted by |path|.
// Returns false and leaves |*out_location| unchanged iff location
// information was not available. (See SourceCodeInfo for
// description of path encoding.)
bool GetSourceLocation(const std::vector<int>& path,
SourceLocation* out_location) const;
private:
typedef FileOptions OptionsType;
const string* name_;
const string* package_;
const DescriptorPool* pool_;
GoogleOnceDynamic* dependencies_once_;
static void DependenciesOnceInit(const FileDescriptor* to_init);
void InternalDependenciesOnceInit() const;
// These are arranged to minimze padding on 64-bit.
int dependency_count_;
int public_dependency_count_;
int weak_dependency_count_;
int message_type_count_;
int enum_type_count_;
int service_count_;
int extension_count_;
Syntax syntax_;
bool is_placeholder_;
// Indicates the FileDescriptor is completed building. Used to verify
// that type accessor functions that can possibly build a dependent file
// aren't called during the process of building the file.
bool finished_building_;
mutable const FileDescriptor** dependencies_;
const string** dependencies_names_;
int* public_dependencies_;
int* weak_dependencies_;
Descriptor* message_types_;
EnumDescriptor* enum_types_;
ServiceDescriptor* services_;
FieldDescriptor* extensions_;
const FileOptions* options_;
const FileDescriptorTables* tables_;
const SourceCodeInfo* source_code_info_;
// IMPORTANT: If you add a new field, make sure to search for all instances
// of Allocate<FileDescriptor>() and AllocateArray<FileDescriptor>() in
// descriptor.cc and update them to initialize the field.
FileDescriptor() {}
friend class DescriptorBuilder;
friend class DescriptorPool;
friend class Descriptor;
friend class FieldDescriptor;
friend class internal::LazyDescriptor;
friend class OneofDescriptor;
friend class EnumDescriptor;
friend class EnumValueDescriptor;
friend class MethodDescriptor;
friend class ServiceDescriptor;
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FileDescriptor);
};
// ===================================================================
// Used to construct descriptors.
//
// Normally you won't want to build your own descriptors. Message classes
// constructed by the protocol compiler will provide them for you. However,
// if you are implementing Message on your own, or if you are writing a
// program which can operate on totally arbitrary types and needs to load
// them from some sort of database, you might need to.
//
// Since Descriptors are composed of a whole lot of cross-linked bits of
// data that would be a pain to put together manually, the
// DescriptorPool class is provided to make the process easier. It can
// take a FileDescriptorProto (defined in descriptor.proto), validate it,
// and convert it to a set of nicely cross-linked Descriptors.
//
// DescriptorPool also helps with memory management. Descriptors are
// composed of many objects containing static data and pointers to each
// other. In all likelihood, when it comes time to delete this data,
// you'll want to delete it all at once. In fact, it is not uncommon to
// have a whole pool of descriptors all cross-linked with each other which
// you wish to delete all at once. This class represents such a pool, and
// handles the memory management for you.
//
// You can also search for descriptors within a DescriptorPool by name, and
// extensions by number.
class LIBPROTOBUF_EXPORT DescriptorPool {
public:
// Create a normal, empty DescriptorPool.
DescriptorPool();
// Constructs a DescriptorPool that, when it can't find something among the
// descriptors already in the pool, looks for it in the given
// DescriptorDatabase.
// Notes:
// - If a DescriptorPool is constructed this way, its BuildFile*() methods
// must not be called (they will assert-fail). The only way to populate
// the pool with descriptors is to call the Find*By*() methods.
// - The Find*By*() methods may block the calling thread if the
// DescriptorDatabase blocks. This in turn means that parsing messages
// may block if they need to look up extensions.
// - The Find*By*() methods will use mutexes for thread-safety, thus making
// them slower even when they don't have to fall back to the database.
// In fact, even the Find*By*() methods of descriptor objects owned by
// this pool will be slower, since they will have to obtain locks too.
// - An ErrorCollector may optionally be given to collect validation errors
// in files loaded from the database. If not given, errors will be printed
// to GOOGLE_LOG(ERROR). Remember that files are built on-demand, so this
// ErrorCollector may be called from any thread that calls one of the
// Find*By*() methods.
// - The DescriptorDatabase must not be mutated during the lifetime of
// the DescriptorPool. Even if the client takes care to avoid data races,
// changes to the content of the DescriptorDatabase may not be reflected
// in subsequent lookups in the DescriptorPool.
class ErrorCollector;
explicit DescriptorPool(DescriptorDatabase* fallback_database,
ErrorCollector* error_collector = NULL);
~DescriptorPool();
// Get a pointer to the generated pool. Generated protocol message classes
// which are compiled into the binary will allocate their descriptors in
// this pool. Do not add your own descriptors to this pool.
static const DescriptorPool* generated_pool();
// Find a FileDescriptor in the pool by file name. Returns NULL if not
// found.
const FileDescriptor* FindFileByName(const string& name) const;
// Find the FileDescriptor in the pool which defines the given symbol.
// If any of the Find*ByName() methods below would succeed, then this is
// equivalent to calling that method and calling the result's file() method.
// Otherwise this returns NULL.
const FileDescriptor* FindFileContainingSymbol(
const string& symbol_name) const;
// Looking up descriptors ------------------------------------------
// These find descriptors by fully-qualified name. These will find both
// top-level descriptors and nested descriptors. They return NULL if not
// found.
const Descriptor* FindMessageTypeByName(const string& name) const;
const FieldDescriptor* FindFieldByName(const string& name) const;
const FieldDescriptor* FindExtensionByName(const string& name) const;
const OneofDescriptor* FindOneofByName(const string& name) const;
const EnumDescriptor* FindEnumTypeByName(const string& name) const;
const EnumValueDescriptor* FindEnumValueByName(const string& name) const;
const ServiceDescriptor* FindServiceByName(const string& name) const;
const MethodDescriptor* FindMethodByName(const string& name) const;
// Finds an extension of the given type by number. The extendee must be
// a member of this DescriptorPool or one of its underlays.
const FieldDescriptor* FindExtensionByNumber(const Descriptor* extendee,
int number) const;
// Finds extensions of extendee. The extensions will be appended to
// out in an undefined order. Only extensions defined directly in
// this DescriptorPool or one of its underlays are guaranteed to be
// found: extensions defined in the fallback database might not be found
// depending on the database implementation.
void FindAllExtensions(const Descriptor* extendee,
std::vector<const FieldDescriptor*>* out) const;
// Building descriptors --------------------------------------------
// When converting a FileDescriptorProto to a FileDescriptor, various
// errors might be detected in the input. The caller may handle these
// programmatically by implementing an ErrorCollector.
class LIBPROTOBUF_EXPORT ErrorCollector {
public:
inline ErrorCollector() {}
virtual ~ErrorCollector();
// These constants specify what exact part of the construct is broken.
// This is useful e.g. for mapping the error back to an exact location
// in a .proto file.
enum ErrorLocation {
NAME, // the symbol name, or the package name for files
NUMBER, // field or extension range number
TYPE, // field type
EXTENDEE, // field extendee
DEFAULT_VALUE, // field default value
INPUT_TYPE, // method input type
OUTPUT_TYPE, // method output type
OPTION_NAME, // name in assignment
OPTION_VALUE, // value in option assignment
OTHER // some other problem
};
// Reports an error in the FileDescriptorProto. Use this function if the
// problem occurred should interrupt building the FileDescriptorProto.
virtual void AddError(
const string& filename, // File name in which the error occurred.
const string& element_name, // Full name of the erroneous element.
const Message* descriptor, // Descriptor of the erroneous element.
ErrorLocation location, // One of the location constants, above.
const string& message // Human-readable error message.
) = 0;
// Reports a warning in the FileDescriptorProto. Use this function if the
// problem occurred should NOT interrupt building the FileDescriptorProto.
virtual void AddWarning(
const string& /*filename*/, // File name in which the error occurred.
const string& /*element_name*/, // Full name of the erroneous element.
const Message* /*descriptor*/, // Descriptor of the erroneous element.
ErrorLocation /*location*/, // One of the location constants, above.
const string& /*message*/ // Human-readable error message.
) {}
private:
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ErrorCollector);
};
// Convert the FileDescriptorProto to real descriptors and place them in
// this DescriptorPool. All dependencies of the file must already be in
// the pool. Returns the resulting FileDescriptor, or NULL if there were
// problems with the input (e.g. the message was invalid, or dependencies
// were missing). Details about the errors are written to GOOGLE_LOG(ERROR).
const FileDescriptor* BuildFile(const FileDescriptorProto& proto);
// Same as BuildFile() except errors are sent to the given ErrorCollector.
const FileDescriptor* BuildFileCollectingErrors(
const FileDescriptorProto& proto,
ErrorCollector* error_collector);
// By default, it is an error if a FileDescriptorProto contains references
// to types or other files that are not found in the DescriptorPool (or its
// backing DescriptorDatabase, if any). If you call
// AllowUnknownDependencies(), however, then unknown types and files
// will be replaced by placeholder descriptors (which can be identified by
// the is_placeholder() method). This can allow you to
// perform some useful operations with a .proto file even if you do not
// have access to other .proto files on which it depends. However, some
// heuristics must be used to fill in the gaps in information, and these
// can lead to descriptors which are inaccurate. For example, the
// DescriptorPool may be forced to guess whether an unknown type is a message
// or an enum, as well as what package it resides in. Furthermore,
// placeholder types will not be discoverable via FindMessageTypeByName()
// and similar methods, which could confuse some descriptor-based algorithms.
// Generally, the results of this option should be handled with extreme care.
void AllowUnknownDependencies() { allow_unknown_ = true; }
// By default, weak imports are allowed to be missing, in which case we will
// use a placeholder for the dependency and convert the field to be an Empty
// message field. If you call EnforceWeakDependencies(true), however, the
// DescriptorPool will report a import not found error.
void EnforceWeakDependencies(bool enforce) { enforce_weak_ = enforce; }
// Internal stuff --------------------------------------------------
// These methods MUST NOT be called from outside the proto2 library.
// These methods may contain hidden pitfalls and may be removed in a
// future library version.
// Create a DescriptorPool which is overlaid on top of some other pool.
// If you search for a descriptor in the overlay and it is not found, the
// underlay will be searched as a backup. If the underlay has its own
// underlay, that will be searched next, and so on. This also means that
// files built in the overlay will be cross-linked with the underlay's
// descriptors if necessary. The underlay remains property of the caller;
// it must remain valid for the lifetime of the newly-constructed pool.
//
// Example: Say you want to parse a .proto file at runtime in order to use
// its type with a DynamicMessage. Say this .proto file has dependencies,
// but you know that all the dependencies will be things that are already
// compiled into the binary. For ease of use, you'd like to load the types
// right out of generated_pool() rather than have to parse redundant copies
// of all these .protos and runtime. But, you don't want to add the parsed
// types directly into generated_pool(): this is not allowed, and would be
// bad design anyway. So, instead, you could use generated_pool() as an
// underlay for a new DescriptorPool in which you add only the new file.
//
// WARNING: Use of underlays can lead to many subtle gotchas. Instead,
// try to formulate what you want to do in terms of DescriptorDatabases.
explicit DescriptorPool(const DescriptorPool* underlay);
// Called by generated classes at init time to add their descriptors to
// generated_pool. Do NOT call this in your own code! filename must be a
// permanent string (e.g. a string literal).
static void InternalAddGeneratedFile(
const void* encoded_file_descriptor, int size);
// Disallow [enforce_utf8 = false] in .proto files.
void DisallowEnforceUtf8() { disallow_enforce_utf8_ = true; }
// For internal use only: Gets a non-const pointer to the generated pool.
// This is called at static-initialization time only, so thread-safety is
// not a concern. If both an underlay and a fallback database are present,
// the underlay takes precedence.
static DescriptorPool* internal_generated_pool();
// For internal use only: Changes the behavior of BuildFile() such that it
// allows the file to make reference to message types declared in other files
// which it did not officially declare as dependencies.
void InternalDontEnforceDependencies();
// For internal use only: Enables lazy building of dependencies of a file.
// Delay the building of dependencies of a file descriptor until absolutely
// necessary, like when message_type() is called on a field that is defined
// in that dependency's file. This will cause functional issues if a proto
// or one of it's dependencies has errors. Should only be enabled for the
// generated_pool_ (because no descriptor build errors are guaranteed by
// the compilation generation process), testing, or if a lack of descriptor
// build errors can be guaranteed for a pool.
void InternalSetLazilyBuildDependencies() {
lazily_build_dependencies_ = true;
// This needs to be set when lazily building dependencies, as it breaks
// dependency checking.
InternalDontEnforceDependencies();
}
// For internal use only.
void internal_set_underlay(const DescriptorPool* underlay) {
underlay_ = underlay;
}
// For internal (unit test) use only: Returns true if a FileDescriptor has
// been constructed for the given file, false otherwise. Useful for testing
// lazy descriptor initialization behavior.
bool InternalIsFileLoaded(const string& filename) const;
// Add a file to unused_import_track_files_. DescriptorBuilder will log
// warnings for those files if there is any unused import.
void AddUnusedImportTrackFile(const string& file_name);
void ClearUnusedImportTrackFiles();
private:
friend class Descriptor;
friend class internal::LazyDescriptor;
friend class FieldDescriptor;
friend class EnumDescriptor;
friend class ServiceDescriptor;
friend class MethodDescriptor;
friend class FileDescriptor;
friend class StreamDescriptor;
friend class DescriptorBuilder;
friend class FileDescriptorTables;
// Return true if the given name is a sub-symbol of any non-package
// descriptor that already exists in the descriptor pool. (The full
// definition of such types is already known.)
bool IsSubSymbolOfBuiltType(const string& name) const;
// Tries to find something in the fallback database and link in the
// corresponding proto file. Returns true if successful, in which case
// the caller should search for the thing again. These are declared
// const because they are called by (semantically) const methods.
bool TryFindFileInFallbackDatabase(const string& name) const;
bool TryFindSymbolInFallbackDatabase(const string& name) const;
bool TryFindExtensionInFallbackDatabase(const Descriptor* containing_type,
int field_number) const;
// Like BuildFile() but called internally when the file has been loaded from
// fallback_database_. Declared const because it is called by (semantically)
// const methods.
const FileDescriptor* BuildFileFromDatabase(
const FileDescriptorProto& proto) const;
// Helper for when lazily_build_dependencies_ is set, can look up a symbol
// after the file's descriptor is built, and can build the file where that
// symbol is defined if necessary. Will create a placeholder if the type
// doesn't exist in the fallback database, or the file doesn't build
// successfully.
Symbol CrossLinkOnDemandHelper(const string& name, bool expecting_enum) const;
// Create a placeholder FileDescriptor of the specified name
FileDescriptor* NewPlaceholderFile(const string& name) const;
FileDescriptor* NewPlaceholderFileWithMutexHeld(const string& name) const;
enum PlaceholderType {
PLACEHOLDER_MESSAGE,
PLACEHOLDER_ENUM,
PLACEHOLDER_EXTENDABLE_MESSAGE
};
// Create a placeholder Descriptor of the specified name
Symbol NewPlaceholder(const string& name,
PlaceholderType placeholder_type) const;
Symbol NewPlaceholderWithMutexHeld(const string& name,
PlaceholderType placeholder_type) const;
// If fallback_database_ is NULL, this is NULL. Otherwise, this is a mutex
// which must be locked while accessing tables_.
Mutex* mutex_;
// See constructor.
DescriptorDatabase* fallback_database_;
ErrorCollector* default_error_collector_;
const DescriptorPool* underlay_;
// This class contains a lot of hash maps with complicated types that
// we'd like to keep out of the header.
class Tables;
google::protobuf::scoped_ptr<Tables> tables_;
bool enforce_dependencies_;
bool lazily_build_dependencies_;
bool allow_unknown_;
bool enforce_weak_;
bool disallow_enforce_utf8_;
std::set<string> unused_import_track_files_;
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DescriptorPool);
};
// inline methods ====================================================
// These macros makes this repetitive code more readable.
#define PROTOBUF_DEFINE_ACCESSOR(CLASS, FIELD, TYPE) \
inline TYPE CLASS::FIELD() const { return FIELD##_; }
// Strings fields are stored as pointers but returned as const references.
#define PROTOBUF_DEFINE_STRING_ACCESSOR(CLASS, FIELD) \
inline const string& CLASS::FIELD() const { return *FIELD##_; }
// Arrays take an index parameter, obviously.
#define PROTOBUF_DEFINE_ARRAY_ACCESSOR(CLASS, FIELD, TYPE) \
inline TYPE CLASS::FIELD(int index) const { return FIELD##s_ + index; }
#define PROTOBUF_DEFINE_OPTIONS_ACCESSOR(CLASS, TYPE) \
inline const TYPE& CLASS::options() const { return *options_; }
PROTOBUF_DEFINE_STRING_ACCESSOR(Descriptor, name)
PROTOBUF_DEFINE_STRING_ACCESSOR(Descriptor, full_name)
PROTOBUF_DEFINE_ACCESSOR(Descriptor, file, const FileDescriptor*)
PROTOBUF_DEFINE_ACCESSOR(Descriptor, containing_type, const Descriptor*)
PROTOBUF_DEFINE_ACCESSOR(Descriptor, field_count, int)
PROTOBUF_DEFINE_ACCESSOR(Descriptor, oneof_decl_count, int)
PROTOBUF_DEFINE_ACCESSOR(Descriptor, nested_type_count, int)
PROTOBUF_DEFINE_ACCESSOR(Descriptor, enum_type_count, int)
PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, field, const FieldDescriptor*)
PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, oneof_decl, const OneofDescriptor*)
PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, nested_type, const Descriptor*)
PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, enum_type, const EnumDescriptor*)
PROTOBUF_DEFINE_ACCESSOR(Descriptor, extension_range_count, int)
PROTOBUF_DEFINE_ACCESSOR(Descriptor, extension_count, int)
PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, extension_range,
const Descriptor::ExtensionRange*)
PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, extension,
const FieldDescriptor*)
PROTOBUF_DEFINE_ACCESSOR(Descriptor, reserved_range_count, int)
PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, reserved_range,
const Descriptor::ReservedRange*)
PROTOBUF_DEFINE_ACCESSOR(Descriptor, reserved_name_count, int)
PROTOBUF_DEFINE_OPTIONS_ACCESSOR(Descriptor, MessageOptions)
PROTOBUF_DEFINE_ACCESSOR(Descriptor, is_placeholder, bool)
PROTOBUF_DEFINE_STRING_ACCESSOR(FieldDescriptor, name)
PROTOBUF_DEFINE_STRING_ACCESSOR(FieldDescriptor, full_name)
PROTOBUF_DEFINE_STRING_ACCESSOR(FieldDescriptor, json_name)
PROTOBUF_DEFINE_STRING_ACCESSOR(FieldDescriptor, lowercase_name)
PROTOBUF_DEFINE_STRING_ACCESSOR(FieldDescriptor, camelcase_name)
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, file, const FileDescriptor*)
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, number, int)
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, is_extension, bool)
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, label, FieldDescriptor::Label)
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, containing_type, const Descriptor*)
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, containing_oneof,
const OneofDescriptor*)
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, index_in_oneof, int)
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, extension_scope, const Descriptor*)
PROTOBUF_DEFINE_OPTIONS_ACCESSOR(FieldDescriptor, FieldOptions)
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, has_default_value, bool)
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, has_json_name, bool)
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_int32 , int32 )
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_int64 , int64 )
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_uint32, uint32)
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_uint64, uint64)
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_float , float )
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_double, double)
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_bool , bool )
PROTOBUF_DEFINE_STRING_ACCESSOR(FieldDescriptor, default_value_string)
PROTOBUF_DEFINE_STRING_ACCESSOR(OneofDescriptor, name)
PROTOBUF_DEFINE_STRING_ACCESSOR(OneofDescriptor, full_name)
PROTOBUF_DEFINE_ACCESSOR(OneofDescriptor, containing_type, const Descriptor*)
PROTOBUF_DEFINE_ACCESSOR(OneofDescriptor, field_count, int)
PROTOBUF_DEFINE_OPTIONS_ACCESSOR(OneofDescriptor, OneofOptions)
PROTOBUF_DEFINE_STRING_ACCESSOR(EnumDescriptor, name)
PROTOBUF_DEFINE_STRING_ACCESSOR(EnumDescriptor, full_name)
PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, file, const FileDescriptor*)
PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, containing_type, const Descriptor*)
PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, value_count, int)
PROTOBUF_DEFINE_ARRAY_ACCESSOR(EnumDescriptor, value,
const EnumValueDescriptor*)
PROTOBUF_DEFINE_OPTIONS_ACCESSOR(EnumDescriptor, EnumOptions)
PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, is_placeholder, bool)
PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, reserved_range_count, int)
PROTOBUF_DEFINE_ARRAY_ACCESSOR(EnumDescriptor, reserved_range,
const EnumDescriptor::ReservedRange*)
PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, reserved_name_count, int)
PROTOBUF_DEFINE_STRING_ACCESSOR(EnumValueDescriptor, name)
PROTOBUF_DEFINE_STRING_ACCESSOR(EnumValueDescriptor, full_name)
PROTOBUF_DEFINE_ACCESSOR(EnumValueDescriptor, number, int)
PROTOBUF_DEFINE_ACCESSOR(EnumValueDescriptor, type, const EnumDescriptor*)
PROTOBUF_DEFINE_OPTIONS_ACCESSOR(EnumValueDescriptor, EnumValueOptions)
PROTOBUF_DEFINE_STRING_ACCESSOR(ServiceDescriptor, name)
PROTOBUF_DEFINE_STRING_ACCESSOR(ServiceDescriptor, full_name)
PROTOBUF_DEFINE_ACCESSOR(ServiceDescriptor, file, const FileDescriptor*)
PROTOBUF_DEFINE_ACCESSOR(ServiceDescriptor, method_count, int)
PROTOBUF_DEFINE_ARRAY_ACCESSOR(ServiceDescriptor, method,
const MethodDescriptor*)
PROTOBUF_DEFINE_OPTIONS_ACCESSOR(ServiceDescriptor, ServiceOptions)
PROTOBUF_DEFINE_STRING_ACCESSOR(MethodDescriptor, name)
PROTOBUF_DEFINE_STRING_ACCESSOR(MethodDescriptor, full_name)
PROTOBUF_DEFINE_ACCESSOR(MethodDescriptor, service, const ServiceDescriptor*)
PROTOBUF_DEFINE_OPTIONS_ACCESSOR(MethodDescriptor, MethodOptions)
PROTOBUF_DEFINE_ACCESSOR(MethodDescriptor, client_streaming, bool)
PROTOBUF_DEFINE_ACCESSOR(MethodDescriptor, server_streaming, bool)
PROTOBUF_DEFINE_STRING_ACCESSOR(FileDescriptor, name)
PROTOBUF_DEFINE_STRING_ACCESSOR(FileDescriptor, package)
PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, pool, const DescriptorPool*)
PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, dependency_count, int)
PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, public_dependency_count, int)
PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, weak_dependency_count, int)
PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, message_type_count, int)
PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, enum_type_count, int)
PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, service_count, int)
PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, extension_count, int)
PROTOBUF_DEFINE_OPTIONS_ACCESSOR(FileDescriptor, FileOptions)
PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, is_placeholder, bool)
PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, message_type, const Descriptor*)
PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, enum_type, const EnumDescriptor*)
PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, service,
const ServiceDescriptor*)
PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, extension,
const FieldDescriptor*)
#undef PROTOBUF_DEFINE_ACCESSOR
#undef PROTOBUF_DEFINE_STRING_ACCESSOR
#undef PROTOBUF_DEFINE_ARRAY_ACCESSOR
// A few accessors differ from the macros...
inline bool Descriptor::IsExtensionNumber(int number) const {
return FindExtensionRangeContainingNumber(number) != NULL;
}
inline bool Descriptor::IsReservedNumber(int number) const {
return FindReservedRangeContainingNumber(number) != NULL;
}
inline bool Descriptor::IsReservedName(const string& name) const {
for (int i = 0; i < reserved_name_count(); i++) {
if (name == reserved_name(i)) {
return true;
}
}
return false;
}
// Can't use PROTOBUF_DEFINE_ARRAY_ACCESSOR because reserved_names_ is actually
// an array of pointers rather than the usual array of objects.
inline const string& Descriptor::reserved_name(int index) const {
return *reserved_names_[index];
}
inline bool EnumDescriptor::IsReservedNumber(int number) const {
return FindReservedRangeContainingNumber(number) != NULL;
}
inline bool EnumDescriptor::IsReservedName(const string& name) const {
for (int i = 0; i < reserved_name_count(); i++) {
if (name == reserved_name(i)) {
return true;
}
}
return false;
}
// Can't use PROTOBUF_DEFINE_ARRAY_ACCESSOR because reserved_names_ is actually
// an array of pointers rather than the usual array of objects.
inline const string& EnumDescriptor::reserved_name(int index) const {
return *reserved_names_[index];
}
inline FieldDescriptor::Type FieldDescriptor::type() const {
if (type_once_) {
type_once_->Init(&FieldDescriptor::TypeOnceInit, this);
}
return type_;
}
inline bool FieldDescriptor::is_required() const {
return label() == LABEL_REQUIRED;
}
inline bool FieldDescriptor::is_optional() const {
return label() == LABEL_OPTIONAL;
}
inline bool FieldDescriptor::is_repeated() const {
return label() == LABEL_REPEATED;
}
inline bool FieldDescriptor::is_packable() const {
return is_repeated() && IsTypePackable(type());
}
inline bool FieldDescriptor::is_map() const {
return type() == TYPE_MESSAGE && is_map_message_type();
}
// To save space, index() is computed by looking at the descriptor's position
// in the parent's array of children.
inline int FieldDescriptor::index() const {
if (!is_extension_) {
return static_cast<int>(this - containing_type()->fields_);
} else if (extension_scope_ != NULL) {
return static_cast<int>(this - extension_scope_->extensions_);
} else {
return static_cast<int>(this - file_->extensions_);
}
}
inline int Descriptor::index() const {
if (containing_type_ == NULL) {
return static_cast<int>(this - file_->message_types_);
} else {
return static_cast<int>(this - containing_type_->nested_types_);
}
}
inline const FileDescriptor* OneofDescriptor::file() const {
return containing_type()->file();
}
inline int OneofDescriptor::index() const {
return static_cast<int>(this - containing_type_->oneof_decls_);
}
inline int EnumDescriptor::index() const {
if (containing_type_ == NULL) {
return static_cast<int>(this - file_->enum_types_);
} else {
return static_cast<int>(this - containing_type_->enum_types_);
}
}
inline const FileDescriptor* EnumValueDescriptor::file() const {
return type()->file();
}
inline int EnumValueDescriptor::index() const {
return static_cast<int>(this - type_->values_);
}
inline int ServiceDescriptor::index() const {
return static_cast<int>(this - file_->services_);
}
inline const FileDescriptor* MethodDescriptor::file() const {
return service()->file();
}
inline int MethodDescriptor::index() const {
return static_cast<int>(this - service_->methods_);
}
inline const char* FieldDescriptor::type_name() const {
return kTypeToName[type()];
}
inline FieldDescriptor::CppType FieldDescriptor::cpp_type() const {
return kTypeToCppTypeMap[type()];
}
inline const char* FieldDescriptor::cpp_type_name() const {
return kCppTypeToName[kTypeToCppTypeMap[type()]];
}
inline FieldDescriptor::CppType FieldDescriptor::TypeToCppType(Type type) {
return kTypeToCppTypeMap[type];
}
inline const char* FieldDescriptor::TypeName(Type type) {
return kTypeToName[type];
}
inline const char* FieldDescriptor::CppTypeName(CppType cpp_type) {
return kCppTypeToName[cpp_type];
}
inline bool FieldDescriptor::IsTypePackable(Type field_type) {
return (field_type != FieldDescriptor::TYPE_STRING &&
field_type != FieldDescriptor::TYPE_GROUP &&
field_type != FieldDescriptor::TYPE_MESSAGE &&
field_type != FieldDescriptor::TYPE_BYTES);
}
inline const FileDescriptor* FileDescriptor::public_dependency(
int index) const {
return dependency(public_dependencies_[index]);
}
inline const FileDescriptor* FileDescriptor::weak_dependency(
int index) const {
return dependency(weak_dependencies_[index]);
}
inline FileDescriptor::Syntax FileDescriptor::syntax() const {
return syntax_;
}
// Can't use PROTOBUF_DEFINE_ARRAY_ACCESSOR because fields_ is actually an array
// of pointers rather than the usual array of objects.
inline const FieldDescriptor* OneofDescriptor::field(int index) const {
return fields_[index];
}
} // namespace protobuf
} // namespace google
#endif // GOOGLE_PROTOBUF_DESCRIPTOR_H__
```
|
```sqlpl
DROP TABLE IF EXISTS t;
CREATE TABLE t (x Decimal(18, 3)) ENGINE = MergeTree ORDER BY x;
INSERT INTO t VALUES (1.1);
SELECT * FROM t WHERE toUInt64(x) = 1;
DROP TABLE t;
CREATE TABLE t (x DateTime64(3)) ENGINE = MergeTree ORDER BY x;
INSERT INTO t VALUES (1000);
SELECT x::UInt64 FROM t WHERE toUInt64(x) = 1;
DROP TABLE t;
```
|
```smalltalk
using O365Clinic.Function.Webhooks.Models;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace O365Clinic.Function.Webhooks
{
public interface ISharePointService
{
/// <summary>
/// Get Incidents
/// </summary>
/// <param name="siteUrl"></param>
/// <returns></returns>
//Task<List<IncidentItem>> GetTickets(string siteUrl);
Task GetListRecentChanges(string siteUrl, string cardPath);
}
}
```
|
The 1998 K League was the 16th season of South Korean professional football league, and was the first season to have been named the "K League". This season is called the "Renaissance of K League" in South Korea. Despite the poor performance of South Korea team at the 1998 FIFA World Cup, the 1998 season of K League recorded a total of 2 million spectators with young star players' popularity for the first time. The three most popular players of them Ko Jong-soo, Lee Dong-gook, and Ahn Jung-hwan were called the "K League Troika".
Regular season
Championship playoffs
Bracket
Final table
Awards
Main awards
Best XI
Source:
See also
1998 K League Championship
1998 Korean League Cup
1998 Korean League Cup (Supplementary Cup)
1998 Korean FA Cup
References
External links
RSSSF
K League seasons
1
South Korea
South Korea
|
Loray () is a commune in the Doubs department in the Bourgogne-Franche-Comté region in eastern France.
Geography
Loray lies south of Pierrefontaine, near Valdahon and Orchamps-Vennes at approximately east of Besançon on the road between Morteau and Besançon. Its highest point is the Roche-Barchey at 1000 m.
Population
Its inhabitants are called Loraitins (or Cabas).
Nearby communes
The neighbouring communes are La Sommette, Flangebouche, Orchamps-Vennes, Plaimbois-Vennes, and Vennes.
See also
Communes of the Doubs department
References
External links
The Clochers of Franche-Comté
Loray on the intercommunal Web site of the department
Communes of Doubs
|
Morskoy Prospekt or Morskoy Avenue () is a street in the Akademgorodok of Novosibirsk, Russia. It is one of the central streets of the science city. The prospekt starts from the intersection with Academician Lavrentyev Avenue and Tereshkova Street, runs south-west and then forms a crossroad with Berdskoye Highway. Berdskoe Highway, a narrow strip of forest and a railway line separate it from the bank of the Novosibirsk Reservoir, popularly known as the Sea of Ob', hence the name (lit. 'Sea Avenue').
The streets adjacent to the prospekt: Detsky Proyezd, Zolotodolinskaya, Pravda, Ilyich, Uchyonykh, Maltsev and Zhemchuzhnaya streets.
History
Street buildings were built in the late 1950s and 1960s.
In 1966, Charles de Gaulle visited Morskoy Prospekt. Residents of the avenue were on balconies and roofs of their houses and looked at the president of France.
Morskoy Prospekt was fully built in 1968.
In 1976, Swedish Prime Minister Olof Palme visited the street.
In 1983, Rajiv Gandhi visited the prospekt.
Morskoy Prospekt was the most expensive place to buy real estate in the city in 2014.
Organizations
The House of Scientists
Gallery
Notable residents
Boris Annin (born October 18, 1936) is a Soviet and Russian scientist in the field of solid mechanics.
Leonid Aseyev (born September 24, 1946) is a Soviet and Russian physicist.
Andrey Ershov (1931–1988) was a Soviet computer scientist, notable as a pioneer in systems programming and programming language research.
Sergei K. Godunov (born July 17, 1929) is a professor at the Sobolev Institute of Mathematics.
Leonid Kantorovich (1912–1986) was a Soviet mathematician and economist, Nobel Prize Laureate. He lived in the house number 44 from 1961 to 1963.
Vladislav Pukhnachyov (born March 29, 1939) is a Soviet and Russian scientist in the field of continuum mechanics.
Vladimir Teshukov (1946–2008) was a Soviet and Russian mechanics.
Bohdan Voitsekhovsky (1922–1999) was a soviet scientist in the field of hydrodynamics and aerodynamics.
Marlen Topchiyan (1934—2014) was a Soviet and Russian scientist in the field of explosives engineering.
Nikolai Yanenko was a Soviet mathematician. He was known for his contributions to computational mathematics and fluid mechanics.
References
Streets in Novosibirsk
Sovetsky District, Novosibirsk
|
```objective-c
/*
*
*/
#ifndef ZEPHYR_INCLUDE_DT_BINDINGS_ST_LIS2DW12_H_
#define ZEPHYR_INCLUDE_DT_BINDINGS_ST_LIS2DW12_H_
/* power-modes */
#define LIS2DW12_DT_LP_M1 0
#define LIS2DW12_DT_LP_M2 1
#define LIS2DW12_DT_LP_M3 2
#define LIS2DW12_DT_LP_M4 3
#define LIS2DW12_DT_HP_MODE 4
/* Filter bandwidth */
#define LIS2DW12_DT_FILTER_BW_ODR_DIV_2 0
#define LIS2DW12_DT_FILTER_BW_ODR_DIV_4 1
#define LIS2DW12_DT_FILTER_BW_ODR_DIV_10 2
#define LIS2DW12_DT_FILTER_BW_ODR_DIV_20 3
/* Tap mode */
#define LIS2DW12_DT_SINGLE_TAP 0
#define LIS2DW12_DT_SINGLE_DOUBLE_TAP 1
/* Free-Fall threshold */
#define LIS2DW12_DT_FF_THRESHOLD_156_mg 0
#define LIS2DW12_DT_FF_THRESHOLD_219_mg 1
#define LIS2DW12_DT_FF_THRESHOLD_250_mg 2
#define LIS2DW12_DT_FF_THRESHOLD_312_mg 3
#define LIS2DW12_DT_FF_THRESHOLD_344_mg 4
#define LIS2DW12_DT_FF_THRESHOLD_406_mg 5
#define LIS2DW12_DT_FF_THRESHOLD_469_mg 6
#define LIS2DW12_DT_FF_THRESHOLD_500_mg 7
/* wakeup duration */
#define LIS2DW12_DT_WAKEUP_1_ODR 0
#define LIS2DW12_DT_WAKEUP_2_ODR 1
#define LIS2DW12_DT_WAKEUP_3_ODR 2
#define LIS2DW12_DT_WAKEUP_4_ODR 3
#endif /* ZEPHYR_INCLUDE_DT_BINDINGS_ST_LIS2DW12_H_ */
```
|
William Archer Redmond DSO (16 October 1886 – 17 April 1932) was an Irish nationalist politician. He served as an MP in the House of Commons of the United Kingdom of Great Britain and Ireland as well as a Teachta Dála (TD) of Dáil Éireann. He was one of the few people to have served in both the House of Commons and in the Oireachtas.
During World War I, he served in the British Army as an officer with an Irish regiment on the Western Front. He was the son of John Redmond, the leader of the Irish Parliamentary Party from 1900 to 1918, and was one of a dynasty of Liberal and Irish Nationalist politicians who are commemorated in Redmond Square in Wexford town.
Early and personal life
William Archer Redmond was born on 16 October 1886 in London, the only son of three children of John Redmond and his wife Johanna. Redmond was educated at Clongowes Wood College and Trinity College Dublin. On 18 November 1930, he married Bridget Mallick of the Curragh, County Kildare. They had no children.
Parliamentary and military career
He was elected as MP for Tyrone East at the December 1910 general election and supported the passing of the 1914 Home Rule Act.
When his father called for support for the British and Allied war effort in World War I, Redmond joined the National Volunteers in the New British Army and served on the Western Front for the duration of the war, first in the Royal Dublin Fusiliers and then in the Irish Guards, rose to the rank of captain and was awarded the DSO. His fellow MP and uncle Willie Redmond, John's brother, also joined up and was killed in 1917. Three other Irish Nationalist MPs also served, J. L. Esmonde, Stephen Gwynn, D. D. Sheehan and former MP Tom Kettle.
When his father died in March 1918, William Archer Redmond resigned his Tyrone seat and successfully defended his father's seat of Waterford at the subsequent by-election. Famously he campaigned in his army uniform and wearing a black armband. His victory ended a run of Sinn Féin victories at by-elections and gave a big, albeit temporary, boost to the morale of supporters of the Irish Parliamentary Party. He did not take part in the First Dáil.
In the general election of December 1918, he was re-elected for Waterford City, becoming one of only two Irish Parliamentary Party MPs outside the six counties of Northern Ireland, and he spoke out strongly in the House of Commons against British military policy in Ireland during the Irish War of Independence.
Dáil career
Following independence, Redmond was elected as an Independent Nationalist deputy in the 4th Dáil for Waterford at the 1923 general election. In 1926, he co-founded the National League Party, appealing to former supporters of the Irish Parliamentary Party, ex-servicemen, and others, including Unionists, alienated by the policies of the Cumann na nGaedheal government. The new party won eight seats at the June 1927 general election.
However Redmond alarmed his supporters by supporting a motion of no confidence placed by Labour Party and Fianna Fáil to bring down the Cumann na nGaedheal government, and replace it with a minority Labour Party–National League administration supported from outside by Fianna Fáil. The attempt failed and in the ensuing general election in September 1927, the party won only two seats, including Redmond. The following year the National League was dissolved and in 1931 Redmond joined Cumann na nGaedheal. He died in April 1932. No by-election was held for the vacancy. His wife Bridget Redmond was elected as a Cumann na nGaedheal TD for Waterford at the 1933 general election.
See also
Families in the Oireachtas
References
External links
Department of the Taoiseach: Irish Soldiers in the First World War
1886 births
1932 deaths
Irish Parliamentary Party MPs
UK MPs 1910–1918
UK MPs 1918–1922
Members of the Parliament of the United Kingdom for County Tyrone constituencies (1801–1922)
Members of the Parliament of the United Kingdom for County Waterford constituencies (1801–1922)
Royal Dublin Fusiliers officers
Irish Guards officers
Irish people of World War I
Companions of the Distinguished Service Order
British Army personnel of World War I
Members of the 4th Dáil
Members of the 5th Dáil
Members of the 6th Dáil
Members of the 7th Dáil
Independent TDs
National League Party TDs
Politicians from County Wexford
William
Alumni of Trinity College Dublin
People educated at Clongowes Wood College
Politicians from County Waterford
Cumann na nGaedheal TDs
Spouses of Irish politicians
Members of the 1st Dáil
Military personnel from London
|
```c
#include <stdio.h>
static struct sss{
short f;
short a[10];
} sss;
#define _offsetof(st,f) ((char *)&((st *) 16)->f - (char *) 16)
int main (void) {
printf ("++++Array of short in struct starting with short:\n");
printf ("size=%d,align=%d\n",
sizeof (sss), __alignof__ (sss));
printf ("offset-short=%d,offset-arrayof-short=%d,\nalign-short=%d,align-arrayof-short=%d\n",
_offsetof (struct sss, f), _offsetof (struct sss, a),
__alignof__ (sss.f), __alignof__ (sss.a));
printf ("offset-short-a[5]=%d,align-short-a[5]=%d\n",
_offsetof (struct sss, a[5]),
__alignof__ (sss.a[5]));
return 0;
}
```
|
Broken is the first extended play (EP) and second major release by American industrial rock band Nine Inch Nails. It was released on September 22, 1992, by Nothing, TVT, and Interscope Records. The EP was produced by frontman Trent Reznor and Flood.
The release consists entirely of new material and replaces the synth-pop style of the band's 1989 debut album Pretty Hate Machine with a considerably heavier sound that would act as a precursor to their second album The Downward Spiral (1994). Its lyrical themes are in line with those of their succeeding work. The record was promoted with music videos for five of the eight songs which were censored due to their violent content, as well as a short film of the same name, which was never officially released, but was later leaked as a bootleg.
Although it was derided by some critics for its lyrical content, Broken also received positive reviews from critics and reached number seven on the US Billboard 200, eventually receiving a platinum certification from the Recording Industry Association of America (RIAA). The recording helped to propel Nine Inch Nails into mainstream popularity, and later received two Grammy Awards (both for Best Metal Performance) for the songs "Wish" and "Happiness in Slavery".
Background
After the commercial and critical success of Pretty Hate Machine (1989), TVT Records, the first record label to sign the band, pressured Trent Reznor to record a very similar album in the hope that it would have similarly successful singles. Steve Gottlieb, the CEO of TVT Records, was insistent that he would not release anything other than an album very similar to Pretty Hate Machine. Reznor demanded his label terminate his contract, due to their restriction of his creative control of the Nine Inch Nails project. They ignored his plea.
Reznor then objected to the label's attempted interference with his intellectual property. This much-publicized feud with TVT led Reznor to use a variety of monikers for the production of his next studio release. Reznor later said that he hated TVT, in part due to their classification of Nine Inch Nails as a synth-pop band. He reached a deal with the record label Interscope Records:
We made it very clear we were not doing another record for TVT. But they made it pretty clear they weren't ready to sell. So I felt like, well, I've finally got this thing going but it's dead. Flood and I had to record Broken under a different band name, because if TVT found out we were recording, they could confiscate all our shit and release it. Jimmy Iovine got involved with Interscope, and we kind of got slave-traded. It wasn't my doing. I didn't know anything about Interscope. And I was real pissed off at him at first because it was going from one bad situation to potentially another one. But Interscope went into it like they really wanted to know what I wanted. It was good, after I put my raving lunatic act on.
Recording
Reznor secretly made the then-untitled recording under various pseudonyms to avoid record company interference. English record producer Flood, who produced "Head Like a Hole" and "Terrible Lie", the first two tracks on Pretty Hate Machine (1989), returned to work in 1992 on the EP for "Wish", "Last" and "Gave Up".
As Reznor explains in retrospect: "Broken [...] had a lot of the super-thick chunk sound, and almost every guitar sound on that record was [tapes consisting of] me playing through an old Zoom pedal and then going direct into Digidesign's TurboSynth [software in a Macintosh computer]. Then I used a couple of key ingredients to make it [be heard as being] unlike any 'real' sound."
The instrumental break of "Physical" (at 3:49) features a half-speed recording of Reznor's dog, Maise, barking, and Sean Beavan's line, "Ow!...fucker!", after Maise bit him. Maise was credited with "barks and roars" in the liner notes as a result. After being owned by Reznor for over three years, Maise died after falling from a three-story balcony during the Self Destruct Tour.
The record underwent development at six different studios, Hell (New Orleans, Louisiana), Royal Recorders at Lake Geneva, Wisconsin, South Beach Studios at Miami, Florida; Village Recorder and A&M Studios at Los Angeles, California, and Le Pig at Beverly Hills, California. The last two studios were later used during the production process for The Downward Spiral (1994). Tom Baker mastered the EP at Futuredisc. Following this step, Reznor presented the recording to Interscope Records in September 1992, and signed to the record label, making Broken Nine Inch Nails' major label debut.
Music and lyrics
Heavier than Pretty Hate Machine, Broken takes influences from industrial metal bands such as Ministry and Godflesh. There are louder mixes and more distortion on every instrument, including John Lennon's Mellotron MKII heard most particularly on "Gave Up". Reznor said he wanted the album to be "an ultra-fast chunk of death" for the listener, something that would "make your ears a little scratchy". In the liner notes, Reznor credited the 1991 Nine Inch Nails touring band as an influence on the EP's sound.
The lyrics are a critique on society, the majority of its themes involve angst, control and dependency struggles. The second promotional single from the EP, "Wish", includes the expletive fuck thrice, used on the lines "Now there's nothing more fucked up I could do", "I'm the one without this soul/I'm the one with this big fucking hole" and "Gotta listen to your big time hard line bad luck fist fuck."
Clocking at roughly one minute, "Pinion" is one of the shortest Nine Inch Nails songs. It features a series of short, ascending, distorted guitar power chords and a collage of atmospheric loops, including a reversed sample of David Bowie's "It's No Game" (which is not credited in the artwork for Broken). A portion of this is used as one of the guitar riffs in "Wish", one of the two promotional singles released from the album. "Help Me I Am in Hell", another instrumental, ends with another uncredited sample, this time from The Empire Strikes Back (1980).
There are two bonus songs, which follow 91 silent, one-second tracks (numbered 7 through 97) on most CD copies, but were included as a separate 3" CD or 7" record with early pressings. "Physical" is a cover of the Adam and the Ants song "Physical (You're So)", originally released on the Kings of the Wild Frontier LP. In 1995, Nine Inch Nails performed "Physical" live with Adam Ant for two nights in a row. After Reznor introduced Ant and Marco Pirroni on the second night, Ant proclaimed to the audience, "It's nice to be on stage with the best fucking band in the world." "Suck" was written by Pigface, whose ever-changing lineup once included Reznor. The slower, sparser, radically different original version appeared a year earlier on Pigface's Gub album.
Packaging
Broken was originally packaged in a trifold-out digipak, containing the six tracks on a regular compact disc and an additional three-inch mini CD with the two remaining songs, covers of Adam and the Ants' "Physical" and Pigface's "Suck". Due to the high cost of producing a two-disc EP, only 250,000 copies were released with the mini CD, subsequently Broken was re-released as one CD in October 1992, having the bonus songs heard on tracks 98 and 99 respectively, without any visual notice except for the credits, and tracks 7–97 each containing one second of silence. The cassette release featured tracks 1–6 on side one, with "Physical" and "Suck" appearing at the tail end of side two, after approximately 15 minutes of silence. The United Kingdom vinyl release was pressed onto a one sided 12" that featured the six main tracks. The two bonus cuts were issued on a 7-inch single given away inside the EP in a white die-cut sleeve (an unusual method for packaging an album on the vinyl format).
All copies include the logo of Nothing Records, a first for the works of Reznor, making the EP itself Nothing's first release. The vanity record label was founded by Reznor along with John Malm Jr., who was his manager at the time, when he had involvement in a feud with TVT Records. It had a short lifespan (Nothing Records existed for nearly 15 years); the label was created in 1992, as Reznor signed to Interscope before TVT entered into a joint venture with that major record label, where he mailed parts culled from his publishing rights to TVT Music, in exchange for the freedom of having his own imprint.
The influence of Reznor's conflict with his former label, TVT, is evident in multiple aspects of the EP. After a long list of credits, the packaging reads, "no thanks: you know who you fucking are" followed by "the slave thinks he is released from bondage only to find a stronger set of chains." These comments are likely directed towards TVT Records' Steve Gottlieb, who refused to let Reznor out of his contract, sparking legal battles between the two parties. The "no thanks" part may be a response to the liner notes of Ministry's Psalm 69: The Way to Succeed and the Way to Suck Eggs album, which featured a cryptic "no thanks, you know who you are."
Aurally, at the beginning of "Physical", Reznor whispers, "eat your heart out, Steve." Visually, in a music video for "Gave Up", the monitor of a Mac computer running Pro Tools reads "fuck you steve".
Despite the addition of "no thanks: you know who you fucking are", there is a "Thank You" section. People listed in that portion include Jimmy Iovine, Ros Earles, Island Records, Eric Greenspan, Rick Rubin, Joe Mcewen, Seymour Stein, Susie Tallman, Mark O'Shea, Ian Copeland, Kevin Westenberg and Sheroa Rees-Davies.
The writing credit for "Suck" caused a minor controversy. Whereas Pigface albums list all contributors to each of the songs, in this case "Atkins/Rieflin/Barker/Reznor" as listed on Gub, the credit on Broken states "written by t. reznor/pigface". On the later Pigface release Truth Will Out, the writing credit for the song is "whatever trent says – really – no shit". Reznor talked about his problem with Pigface in an unreleased 1992 Melody Maker interview. Reznor says he came in at the end of the Gub recording session, when time was running out, sang the lyrics for "Suck" over the leftover drum snippets they had, threw it together and said it was done. He stated he does not like the recording. Later when Pigface were going to go on tour, Reznor taught them the proper music he had written for the song, which is completely different than the music that he sang over on the Pigface studio recording. Pigface toured with the song with Nine Inch Nails, even playing the song with Reznor a few times. (The original Pigface recording is abstract noise and occasional bass over drum beats; nothing like Reznor's version.) The following year, Reznor put out his version on Broken. In the liner notes, he mentions that there were personality conflicts and people saying they deserve more than they have.
Release and reception
"It's heavy", wrote Danny Scott in Select, "it's loud and it'll rip your stinkin' head from your shoulders if you so much as breathe without permission." "Beats are hammered home with the gleeful force of a dentist's drill", said Peter Kane in Q, "while layers of rabid guitars and Reznor's spiteful voice pile on the nihilistic agony." "Reznor has shaken off the shackles of influence", observed NME, "and found his own suitably idiosyncratic niche." "Like a harrowing rape account", marveled Making Music, "it's an intensely vicious and shocking 30 minutes."
Writing for The Baltimore Sun, J. D. Considine stated: "Harder than Ministry, hookier than Nitzer Ebb, this EP is everything industrial music should be." CMJ described Broken as "an astonishingly cold, brutal and bleak EP."
The EP was certified platinum by the Recording Industry Association of America (RIAA) on December 18, 1992, despite a complete absence of touring in support of it. The first promotional single, "Happiness in Slavery", received moderate airplay, but its video's depiction of Bob Flanagan being pleasured, tortured, and killed on a device led to MTV banning it outright. This stunted the single's growth, but the track "Wish" was much more successful with an aggressive live performance on the music video, then later winning a Grammy for Best Metal Performance. Reznor later quipped that he wanted his gravestone to read "Reznor: Died. Said 'Fist Fuck', Won a Grammy."
Music videos
Not long after the EP's release, a short horror musical film also named Broken was created during and after the production of the EP. It was rumored to be a snuff film with all of its songs with the exception of "Last", "Physical", and "Suck" playing to a scene. This film was directed by Peter Christopherson of Throbbing Gristle and Coil fame. A music video for "Gave Up" would prove to be part of the film, as well as the videos for "Happiness in Slavery" and "Wish". Portions of Broken would, however, be released as part of the Closure VHS, which was released after The Downward Spiral. Due to the graphic substance of "Gave Up", an alternative version of the music video consisting of the song being performed at Le Pig studios by Reznor, a young Marilyn Manson, Richard Patrick and Chris Vrenna was released to MTV. Much of the cast, aside from Bob Flanagan in "Happiness in Slavery", and the band itself in "Wish", is unknown. The film is generally credited to be directed by Christopherson, although the music videos themselves were directed by various other people: "Pinion" and "Help Me I Am in Hell" is credited to Eric Goode and Serge Becker, while "Happiness in Slavery" is credited to Jon Reiss.
A music video for "Happiness in Slavery" was universally banned, though a few attempts to air it were successful. An episode of Raw Time aired "Happiness in Slavery" at 3:00 AM to unanimously positive response from viewers. Another program, Music Link, broadcast the video at midnight.
Broken has not been given an official commercial release (according to Reznor, because they wanted to avoid the film overshadowing the prominence of the music), thus adding to its mythological status in alternative culture. The original hand-dubbed tapes were distributed by Reznor to various friends with dropouts at certain points so he could know who distributed any copies that might surface. Reznor, commenting in the "Access" section of the NIN website, implied that Gibby Haynes was responsible for the most prominent leak. This copy was traded on VHS tapes for years (resulting in many poor-quality, high-generation copies), and was later encoded in MPEG and AVI formats and distributed extensively through peer-to-peer networks and Nine Inch Nails fan websites. These are generally not of the highest quality, as they are not first-generation copies.
On December 30, 2006, an unofficial version of the film was released on a DVD disc image and distributed via BitTorrent at The Pirate Bay by the same anonymous user called "seed0" who uploaded the leaked DVD version of Closure. The DVD image represents a significant upgrade in visual and audio quality from "Broken 2.0.", and includes the oft-missing video for "Help Me I Am in Hell". Fans have speculated that this version of the film has been sourced directly from the master tapes, and that Reznor himself may have been the source of this leak along with the Closure DVD leak, as implied by a post on his official blog: "12/21/06 : Happy Holidays! This one is a guilt-free download. (shhhh - I didn't say that out loud). If you know what I'm talking about, cool."
Track listing
Notes
A few variations of Broken exist, mostly due to different track listing arrangements:
The very first US CD pressings of the album had "Physical" and "Suck" included on a second disc, a three-inch mini CD. Many pressings outside the US had no second disc and these songs were tracks 7 and 8 on the main disc. Later American pressings eliminated the second disc as well and included the songs on the main disc as tracks 98 and 99. On this version tracks 7–97 consist of 4 seconds of silence each resulting in a slightly longer total playtime (33:09 vs. 31:35).
On most pressings, US and otherwise, tracks 7/98 and 8/99 are not listed in the track listing on the back of the case. Some pressings also omit track 6, "Gave Up" from the rear listing as well.
The only US 12-inch vinyl pressings released prior to the 2017 Definitive Edition ("promotional" only) omit the two instrumental tracks, "Pinion" and "Help Me I Am in Hell".
Unlike the relatively large number of various CD versions, almost all cassette pressings across all regions include tracks 1–6 on side A and tracks 7–8 on side B.
All vinyl pressings include "Physical" and "Suck" on a separate seven-inch disc.
Personnel
Trent Reznor – writing, performance, production
Flood – production
Martin Atkins – drums (2, 8)
Chris Vrenna – drums (6)
Tom Baker – mastering
Charts
Certifications
Notes
References
Bibliography
External links
Album Review at The Daily Collegian (Penn State)
Album Review at Entertainmentopia
Multi-Track zip of Last from the Broken EP, the separated channels of the song used for remixing
Multi-Track zip of Wish from the Broken EP
1992 debut EPs
Albums produced by Flood (producer)
Albums produced by Trent Reznor
Albums recorded in a home studio
Alternative metal EPs
Industrial metal EPs
Interscope Records EPs
Nine Inch Nails EPs
Nothing Records EPs
TVT Records EPs
|
Amy Beth Kirsten (born 1972) is an American composer. She has worked with musical groups and ensembles including the Chicago Symphony Orchestra, American Composers Orchestra, and eighth blackbird, and is one of the co-founders of HOWL ensemble.
Life and career
Kirsten began writing songs and choral pieces while learning the piano as a child. She was a vocal and piano major at Benedictine University but only began formal composition training at the age of 30. She received her Doctor of Musical Arts at the Peabody Institute and Master of Music at Roosevelt University.
Kirsten is most notable for her works for “Composed Theatre”, which is referred by Matthias Rebstock as “the creative process and the performance of pieces that are determined by compositional strategies and, in a broader sense, by compositional thinking.” Her major theatrical works include Savior (2016-2018) and QUIXOTE (2015-2017), and Colombine's Paradise Theatre (2010-2013). Her notable instrumental compositions include Pirouette On a Moon Sliver (2011) for flute solo and Drink Me (2010) for chamber orchestra, both with elements of vocalization.
Kirsten currently serves on the composition faculty at Longy School of Music and is a visiting professor at the Curtis Institute of Music. She previously served on the faculty of the Peabody Institute of Johns Hopkins University from 2015 to 2017. She has also been the faculty and advisory board of the annual highSCORE festival in Pavia, Italy since 2011.
References
1972 births
Living people
American women composers
21st-century American composers
Benedictine University alumni
Peabody Institute alumni
Roosevelt University alumni
Longy School of Music of Bard College faculty
21st-century American women musicians
21st-century women composers
|
The Army Light Aviation Unit (, UALE) was the planned aviation unit of the Portuguese Army. Created in 2000 as the Army Light Aviation Group (GALE), it was the Army's unit dedicated to missions of light aviation, being integrated in the Army Forces System, under the operational command of the Ground Forces Operational Command (). It was planned to be equipped with light fire support and medium maneuver helicopters. The process of helicopter procurement, however, suffered successive setbacks until being finally canceled in 2012, causing the unit disbandment in 2015.
History
Background
The Portuguese Army maintained its own aviation arm from 1914 to 1952. This arm received a high degree of autonomy in 1937, including its own separate chain of command, although continuing to be administratively connected to the Army. In the early 1950s, the decision was taken to completely separate it from the Army, becoming an entirely independent branch of the Armed Forces. The decision was also taken to separate the Portuguese Naval Aviation from the Navy and to put it under the control of the new independent air branch. The new branch created in 1952, became the Portuguese Air Force, unifying all the Portuguese military aviation assets and operations under a single command.
At the same time that the process of the separation of the Portuguese Air Force was being carried away, the Army felt the need to continue to maintain its own light aviation service to support the artillery arm in the observation and direction of fire over targets located beyond the horizon. This need led the Army minister General Abranches Pinto to boost the process of activation of what was intended to be the future Artillery Observation Light Aviation. The process advances in 1952, with the sending of officers for training in the US Army Artillery Aviation, with the construction of the General Abrantes Pinto Air Field in the artillery range area of the Army Artillery School at Vendas Novas and with the reception of 22
Piper Super-Cub L-21 observation and liaison planes. Eight of these aircraft started to be permanently based at the Army Artillery School Air Field, being used in the artillery observation role and piloted by artillery arm pilots-observers. The remaining aircraft were only used in maneuvers, being piloted by Air Force pilots. Meanwhile, the concept of Army light aviation evolved and plans were being made to equip it in the future also with helicopters and to give it other missions besides those related with the artillery. The process of the raising of the Army Light Aviation is however terminated in 1955, with the transference of the Piper Super-Cub aircraft to the Air Force, these forming an Army cooperation Liaison and Training Flight based at the Tancos Air Base.
During the Portuguese Overseas War (1961-1974), all military air assets were part of the Air Force. These were employed both in independent operations and in cooperation with the land and naval forces, under the coordination of the joint military commands. The Air Force was equipped with assets oriented for the counter-insurgency, including new helicopters that were used to perform joint helicopter operations involving Commandos and Paratroopers (these then being part of the Air Force). Occasionally, the Air Force established detachments of cooperation that operated under the command of Army units.
Creation of the Army Light Aviation Unit
In the 1980s, based on the experience gained in Africa and the increasingly importance of the helicopter in NATO military operations, a work group was created by the Army's Cavalry Arm Directorate to study and plan the creation of a light aviation unit. On July 12, 1991, the National Defense Superior Council decided to add a light aviation unit to the Medium Term Forces System (). On June 30, 1993, the Ministry of National Defense approved the addition of the Army Light Aviation Group (, GALE) to the list of units to be created, and on August 31 the financing of the program.
A commission to prepare for the creation of the unit was then created in 1997. On June 1, 2000, the Army Light Aviation Group was officially formed.
On July 1, 2006, the Army Light Aviation Group (GALE) was re-designated as Army Light Aviation Unit (, UALE), as part of the Army's Base Structure and of the Rapid Reaction Brigade.
During its existence, the UALE was responsible to serve as the administrative parent unit of the Communications Company of the Rapid Reaction Brigade' and to operate and maintain the Tancos airfield. Due to the lack of aircraft, it however never performed air activities, which were supposedly the reason for its existence.
The unit was disbanded in the scope of the new Army organization established in July 2015.
Aircraft procurement
The unit was originally intended to be equipped with nine light utility helicopters and with ten medium transport helicopters.
In 1999, the Eurocopter EC635 T1 was acquired for the light utility, anti-tank and reconnaissance role. The EC635 had been specifically developed by Eurocopter precisely to meet the Portuguese Army requirements for its light aviation unit. However, the EC635 program was cancelled in 2002 with the lack of a certification to fire HOT 2 anti-tank missiles and the delivery of the helicopters being cited as the official reason.
In June 2001, the NHIndustries NH90 TTH was selected for the medium transport role.
In 2004, the Portuguese government prepared to open a new competition for the acquisition of light helicopters for both the UALE and the Portuguese Air Force, to replace the Alouette III, but the competition was eventually cancelled.
In June 2012, the Portuguese government officially announced that it would cancel the order of all ten NHI NH90 due to budget cuts, thus compromising the future of the UALE.
Operational history
The pilots and ground crews of the UALE underwent training with the Portuguese Air Force, with pilots undergoing flight training in the PoAF's Alouette III helicopters. The Army's pilot have also received training on the Eurocopter EC135 in the Spanish Army Airmobile Force.
Between 2007 and 2012, under an agreement with EMA — Empresa de Meios Aéreos, S. A., a company owned by the Portuguese government, Army pilots flew EMA's Kamov Ka-32 helicopters in fire-fighting and other public interest missions for the Portuguese Ministry of Internal Administration.
See also
Army aviation
Portuguese Air Force
NHIndustries
References
Bibliography
External links
Unidade de Aviação Ligeira do Exército, official website
Army aviation units and formations
Army units and formations of Portugal
Military units and formations established in 2000
Military units and formations disestablished in 2015
Portuguese Army
|
The 121st Boat Race took place on 29 March 1975. Held annually, the Boat Race is a side-by-side rowing race between crews from the Universities of Oxford and Cambridge along the River Thames. Cambridge won their seventh race in eight years by lengths in a time of 19 minutes and 27 seconds. The race was umpired by former Oxford rower Christopher Davidge.
In the reserve race, Oxford's Isis beat Cambridge's Goldie by lengths. Cambridge won the 30th Women's Boat Race.
Background
The Boat Race is a side-by-side rowing competition between the University of Oxford (sometimes referred to as the "Dark Blues") and the University of Cambridge (sometimes referred to as the "Light Blues"). The race was first held in 1829, and since 1845 has taken place on the Championship Course on the River Thames in southwest London. The rivalry is a major point of honour between the two universities, followed throughout the United Kingdom and broadcast worldwide. Oxford went into the race as reigning champions, having won the previous year's race by lengths, with Cambridge leading overall with 67 victories to Oxford's 52 (excluding the "dead heat" of 1877). The umpire for the race was Christopher Davidge, who had rowed for Oxford in the 1949, 1951 and 1952 races, and was a non-rowing Oxford University Boat Club president for the 1950 race.
The first Women's Boat Race took place in 1927, but did not become an annual fixture until the 1960s. Up until 2014, the contest was conducted as part of the Henley Boat Races, but as of the 2015 race, it is held on the River Thames, on the same day as the men's main and reserve races. The reserve race, contested between Oxford's Isis boat and Cambridge's Goldie boat has been held since 1965. It usually takes place on the Tideway, prior to the main Boat Race.
In the month leading up to the race, Cambridge's crew saw some significant changes, including the removal of David Sturge (who had rowed in the 1973 race) due to glandular fever. However, the Cambridge boat club president Steve Tourek was circumspect: "Cambridge might be slower than planned but still fast enough to beat Oxford." On 24 March 1975, Cambridge beat Oxford's record time (set five days earlier) between Hammersmith Bridge and the Mile Post by two seconds. The following day, Oxford's coach Dan Topolski (who had rowed for the Dark Blues in the 1967 and 1968 races) revealed that the Oxford reserve crew, Isis, had equalled the record time, downplaying Cambridge's efforts: "Shows how fast conditions really were yesterday." Cambridge coach Lou Barry remarked of his charges: "this is a fast crew".
Crews
The Cambridge crew weighed an average of 13 st 9.75 lb (86.8 kg), per rower more than their opponents. Oxford's crew contained two former Blues in boat club president Nick Tee and stroke Graham Innes, while Cambridge saw Nick Bradley, Henry Clay and Tourek return from the 1974 boat. Although the British international rower David Sturge was replaced through illness prior to the race, the Light Blues also saw international-standard rowers Alistair Christie and James Macleod in the crew, both of whom had withdrawn from selection for the 1974 race to represent Great Britain. Only two competitors in the race were registered as "overseas" Blues, Oxford's number five John Hutchings and his counterpart and Tourek, both from the United States.
Race
Cambridge started as pre-race favourite; according to the author and former rower Dickie Burnell, although Oxford had some "useful new recruits" no-one "outside their immediate camp thought they could win." Oxford won the toss and elected to start from the Surrey station. Oxford took an early lead, but by the Mile Post, Cambridge had recovered to lead by two seconds. Extending their lead, the Light Blues gained a clear water advantage by Harrods Furniture Depository and moved in front of the Dark Blue boat. Shooting Hammersmith Bridge five seconds ahead, Cambridge held a length-and-a-quarter lead, which they defended against a number of Oxford pushes. Midway round the Surrey bend, Oxford's bow man Andrew Baird's oar came out of its gate, allowing Cambridge to increase their lead by another length. A seven-second lead at Chiswick Steps was extended to nine seconds by Barnes Bridge, and along the final bend, Cambridge pushed their lead further out to nearly four lengths, passing the finishing post in 19 minutes 27 seconds, thirteen seconds ahead of their rivals. It was Cambridge's seventh victory in the previous eight years, having lost to Oxford in 1974.
In the reserve race, Oxford's Isis beat Cambridge's Goldie by lengths, their first win since the 1966 race. In the 30th running of the Women's Boat Race, Cambridge triumphed, winning their 13th consecutive race.
Reaction
Oxford's Baird claimed "I might have caught a crab, but I do not really know what happened." Cambridge number six MacLeod said of the Dark Blues: "They kept coming at us time and time again. I was only sure of victory in the last mile of the race." Christopher Dodd, writing in The Guardian was impressed: "The contest had a rare element ... it was a race nearly all the way, and was not all over in the first 20 stokes as has so often been the case in recent years." Burnell suggested it was a race for the aficionados: "This was surely one of those so common Boat Races, which are hard fought all the way, yet never exciting from the point of view of the average spectator."
References
Notes
Bibliography
External links
Official website
The Boat Race
1975 in English sport
1975 in rowing
1975 sports events in London
March 1975 sports events in the United Kingdom
|
```php
<?php
/**
*/
namespace OC\Files\ObjectStore;
use OCP\Files\ObjectStore\IObjectStore;
use OCP\Files\Storage\IStorage;
use function is_resource;
/**
* Object store that wraps a storage backend, mostly for testing purposes
*/
class StorageObjectStore implements IObjectStore {
/** @var IStorage */
private $storage;
/**
* @param IStorage $storage
*/
public function __construct(IStorage $storage) {
$this->storage = $storage;
}
/**
* @return string the container or bucket name where objects are stored
* @since 7.0.0
*/
public function getStorageId() {
$this->storage->getId();
}
/**
* @param string $urn the unified resource name used to identify the object
* @return resource stream with the read data
* @throws \Exception when something goes wrong, message will be logged
* @since 7.0.0
*/
public function readObject($urn) {
$handle = $this->storage->fopen($urn, 'r');
if (is_resource($handle)) {
return $handle;
}
throw new \Exception();
}
public function writeObject($urn, $stream, ?string $mimetype = null) {
$handle = $this->storage->fopen($urn, 'w');
if ($handle) {
stream_copy_to_stream($stream, $handle);
fclose($handle);
} else {
throw new \Exception();
}
}
/**
* @param string $urn the unified resource name used to identify the object
* @return void
* @throws \Exception when something goes wrong, message will be logged
* @since 7.0.0
*/
public function deleteObject($urn) {
$this->storage->unlink($urn);
}
public function objectExists($urn) {
return $this->storage->file_exists($urn);
}
public function copyObject($from, $to) {
$this->storage->copy($from, $to);
}
}
```
|
The Baltimore Brigade was a professional arena football team based in Baltimore, Maryland, that played in the Arena Football League (AFL) from 2017 to 2019. The team's home arena was the Royal Farms Arena. The franchise was owned by Monumental Sports & Entertainment (Ted Leonsis, chairman), which also owned the Washington Valor of the AFL, as well as the Washington Wizards of the National Basketball Association (NBA), Washington Mystics of the Women's National Basketball Association (WNBA), and Washington Capitals of the National Hockey League (NHL).
After the 2019 season, the entire league ceased operations.
History
The Arena Football League and Monumental Sports & Entertainment both announced on November 14, 2016, that it had granted an expansion franchise to begin play for the 2017 season in Baltimore. Monumental Sports & Entertainment is operated by Ted Leonsis, the majority owner, who had also previously been granted an expansion team in the Washington Valor to begin play the same season.
Although other indoor football leagues have hosted teams in Baltimore in the past (such as the Baltimore Blackbirds and Baltimore Mariners), this is the first Arena Football League franchise to be located in Baltimore, and the first in the state of Maryland since the Washington/Maryland Commandos, a charter league franchise that played in the DC suburb of Landover for its first season.
On December 14, 2016, former Los Angeles KISS coach Omarr Smith was named the team's first head coach.
On January 25, 2017, the team was officially announced as the Baltimore Brigade, named for the military history and in reference to the War of 1812 and the inspiration for the penning of the poem that would later become known as "The Star-Spangled Banner", the U.S.A.'s national anthem.
Number 19 was never issued to any player out of respect to their late Baltimore Colts great Johnny Unitas.
On July 20, 2018, the Brigade reached their first ArenaBowl championship game, ArenaBowl XXXI, after defeating the Philadelphia Soul in the second leg of a two-game aggregate playoff series. They won the first game 57–45 and the second 53–41. In ArenaBowl XXXI, they hosted against the Washington Valor, who scored a 69–55 upset victory.
In a January 2019 interview with Forbes, Leonsis noted that the Brigade was not particularly successful in regard to finances, and that he mainly used the team and its Washington counterpart to experiment with ideas to later use with his more prominent sports properties such as the Wizards, Mystics and Capitals. After the 2019 season, the league initially announced it was ending all local team operations and looking into becoming a traveling league. However, the entire league ceased operations after the AFL filed for bankruptcy in November 2019.
As of 2022, the Brigade's field was being used by the San Diego Strike Force of the Indoor Football League.
Players
Individual awards
Coaches and personnel
Head coaches
Staff
Season-by-season results
References
External links
Official website
American football teams in Baltimore
2016 establishments in Maryland
2019 disestablishments in Maryland
|
```smalltalk
using System;
using System.ComponentModel;
using XCode;
using XCode.Configuration;
using XCode.DataAccessLayer;
namespace STOD.Entity
{
/// <summary></summary>
[Serializable]
[DataObject]
[Description("")]
[BindIndex("IX_History_CreateTime", false, "CreateTime")]
[BindTable("History", Description = "", ConnName = "STOD", DbType = DatabaseType.None)]
public partial class History
{
#region
private Int32 _ID;
/// <summary></summary>
[DisplayName("")]
[Description("")]
[DataObjectField(true, true, false, 0)]
[BindColumn("ID", "", "")]
public Int32 ID { get => _ID; set { if (OnPropertyChanging("ID", value)) { _ID = value; OnPropertyChanged("ID"); } } }
private String _Category;
/// <summary></summary>
[DisplayName("")]
[Description("")]
[DataObjectField(false, false, true, 50)]
[BindColumn("Category", "", "")]
public String Category { get => _Category; set { if (OnPropertyChanging("Category", value)) { _Category = value; OnPropertyChanged("Category"); } } }
private String _Action;
/// <summary></summary>
[DisplayName("")]
[Description("")]
[DataObjectField(false, false, true, 50)]
[BindColumn("Action", "", "")]
public String Action { get => _Action; set { if (OnPropertyChanging("Action", value)) { _Action = value; OnPropertyChanged("Action"); } } }
private String _UserName;
/// <summary></summary>
[DisplayName("")]
[Description("")]
[DataObjectField(false, false, true, 50)]
[BindColumn("UserName", "", "")]
public String UserName { get => _UserName; set { if (OnPropertyChanging("UserName", value)) { _UserName = value; OnPropertyChanged("UserName"); } } }
private Int32 _CreateUserID;
/// <summary></summary>
[DisplayName("")]
[Description("")]
[DataObjectField(false, false, false, 0)]
[BindColumn("CreateUserID", "", "")]
public Int32 CreateUserID { get => _CreateUserID; set { if (OnPropertyChanging("CreateUserID", value)) { _CreateUserID = value; OnPropertyChanged("CreateUserID"); } } }
private String _CreateIP;
/// <summary>IP</summary>
[DisplayName("IP")]
[Description("IP")]
[DataObjectField(false, false, true, 50)]
[BindColumn("CreateIP", "IP", "")]
public String CreateIP { get => _CreateIP; set { if (OnPropertyChanging("CreateIP", value)) { _CreateIP = value; OnPropertyChanged("CreateIP"); } } }
private DateTime _CreateTime;
/// <summary></summary>
[DisplayName("")]
[Description("")]
[DataObjectField(false, false, true, 0)]
[BindColumn("CreateTime", "", "")]
public DateTime CreateTime { get => _CreateTime; set { if (OnPropertyChanging("CreateTime", value)) { _CreateTime = value; OnPropertyChanged("CreateTime"); } } }
private String _Remark;
/// <summary></summary>
[DisplayName("")]
[Description("")]
[DataObjectField(false, false, true, 500)]
[BindColumn("Remark", "", "")]
public String Remark { get => _Remark; set { if (OnPropertyChanging("Remark", value)) { _Remark = value; OnPropertyChanged("Remark"); } } }
#endregion
#region /
/// <summary>/ </summary>
/// <param name="name"></param>
/// <returns></returns>
public override Object this[String name]
{
get
{
switch (name)
{
case "ID": return _ID;
case "Category": return _Category;
case "Action": return _Action;
case "UserName": return _UserName;
case "CreateUserID": return _CreateUserID;
case "CreateIP": return _CreateIP;
case "CreateTime": return _CreateTime;
case "Remark": return _Remark;
default: return base[name];
}
}
set
{
switch (name)
{
case "ID": _ID = value.ToInt(); break;
case "Category": _Category = Convert.ToString(value); break;
case "Action": _Action = Convert.ToString(value); break;
case "UserName": _UserName = Convert.ToString(value); break;
case "CreateUserID": _CreateUserID = value.ToInt(); break;
case "CreateIP": _CreateIP = Convert.ToString(value); break;
case "CreateTime": _CreateTime = value.ToDateTime(); break;
case "Remark": _Remark = Convert.ToString(value); break;
default: base[name] = value; break;
}
}
}
#endregion
#region
/// <summary></summary>
public partial class _
{
/// <summary></summary>
public static readonly Field ID = FindByName("ID");
/// <summary></summary>
public static readonly Field Category = FindByName("Category");
/// <summary></summary>
public static readonly Field Action = FindByName("Action");
/// <summary></summary>
public static readonly Field UserName = FindByName("UserName");
/// <summary></summary>
public static readonly Field CreateUserID = FindByName("CreateUserID");
/// <summary>IP</summary>
public static readonly Field CreateIP = FindByName("CreateIP");
/// <summary></summary>
public static readonly Field CreateTime = FindByName("CreateTime");
/// <summary></summary>
public static readonly Field Remark = FindByName("Remark");
static Field FindByName(String name) => Meta.Table.FindByName(name);
}
/// <summary></summary>
public partial class __
{
/// <summary></summary>
public const String ID = "ID";
/// <summary></summary>
public const String Category = "Category";
/// <summary></summary>
public const String Action = "Action";
/// <summary></summary>
public const String UserName = "UserName";
/// <summary></summary>
public const String CreateUserID = "CreateUserID";
/// <summary>IP</summary>
public const String CreateIP = "CreateIP";
/// <summary></summary>
public const String CreateTime = "CreateTime";
/// <summary></summary>
public const String Remark = "Remark";
}
#endregion
}
}
```
|
The second encirclement campaign can refer to one of several encirclement campaigns launched during the 1930s by the Nationalist Government of China against the Chinese soviets created by the Chinese Communist Party. These include:
Second encirclement campaign against the Jiangxi Soviet, April 1, 1931 to May 31, 1931
Second encirclement campaign against the Eyuwan Soviet, April 1931 to July 1931
Second encirclement campaign against the Honghu Soviet, March 1, 1931, to early June, 1931
Second encirclement campaign against the Hubei-Henan-Shaanxi Soviet, February 1935 to April 18, 1935
Second encirclement campaign against the Shaanxi-Gansu Soviet, April 1935 to July, 1935
|
```go
// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
package cloudwatchevents
import (
"fmt"
"time"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/awsutil"
"github.com/aws/aws-sdk-go/aws/request"
"github.com/aws/aws-sdk-go/private/protocol"
"github.com/aws/aws-sdk-go/private/protocol/jsonrpc"
)
const opActivateEventSource = "ActivateEventSource"
// ActivateEventSourceRequest generates a "aws/request.Request" representing the
// client's request for the ActivateEventSource operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ActivateEventSource for more information on using the ActivateEventSource
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the ActivateEventSourceRequest method.
// req, resp := client.ActivateEventSourceRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) ActivateEventSourceRequest(input *ActivateEventSourceInput) (req *request.Request, output *ActivateEventSourceOutput) {
op := &request.Operation{
Name: opActivateEventSource,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &ActivateEventSourceInput{}
}
output = &ActivateEventSourceOutput{}
req = c.newRequest(op, input, output)
req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
return
}
// ActivateEventSource API operation for Amazon CloudWatch Events.
//
// Activates a partner event source that has been deactivated. Once activated,
// your matching event bus will start receiving events from the event source.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation ActivateEventSource for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - InvalidStateException
// The specified state is not a valid state for an event source.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - OperationDisabledException
// The operation you are attempting is not available in this region.
//
// See also, path_to_url
func (c *CloudWatchEvents) ActivateEventSource(input *ActivateEventSourceInput) (*ActivateEventSourceOutput, error) {
req, out := c.ActivateEventSourceRequest(input)
return out, req.Send()
}
// ActivateEventSourceWithContext is the same as ActivateEventSource with the addition of
// the ability to pass a context and additional request options.
//
// See ActivateEventSource for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) ActivateEventSourceWithContext(ctx aws.Context, input *ActivateEventSourceInput, opts ...request.Option) (*ActivateEventSourceOutput, error) {
req, out := c.ActivateEventSourceRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opCancelReplay = "CancelReplay"
// CancelReplayRequest generates a "aws/request.Request" representing the
// client's request for the CancelReplay operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CancelReplay for more information on using the CancelReplay
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the CancelReplayRequest method.
// req, resp := client.CancelReplayRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) CancelReplayRequest(input *CancelReplayInput) (req *request.Request, output *CancelReplayOutput) {
op := &request.Operation{
Name: opCancelReplay,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &CancelReplayInput{}
}
output = &CancelReplayOutput{}
req = c.newRequest(op, input, output)
return
}
// CancelReplay API operation for Amazon CloudWatch Events.
//
// Cancels the specified replay.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation CancelReplay for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - IllegalStatusException
// An error occurred because a replay can be canceled only when the state is
// Running or Starting.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) CancelReplay(input *CancelReplayInput) (*CancelReplayOutput, error) {
req, out := c.CancelReplayRequest(input)
return out, req.Send()
}
// CancelReplayWithContext is the same as CancelReplay with the addition of
// the ability to pass a context and additional request options.
//
// See CancelReplay for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) CancelReplayWithContext(ctx aws.Context, input *CancelReplayInput, opts ...request.Option) (*CancelReplayOutput, error) {
req, out := c.CancelReplayRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opCreateApiDestination = "CreateApiDestination"
// CreateApiDestinationRequest generates a "aws/request.Request" representing the
// client's request for the CreateApiDestination operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateApiDestination for more information on using the CreateApiDestination
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the CreateApiDestinationRequest method.
// req, resp := client.CreateApiDestinationRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) CreateApiDestinationRequest(input *CreateApiDestinationInput) (req *request.Request, output *CreateApiDestinationOutput) {
op := &request.Operation{
Name: opCreateApiDestination,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &CreateApiDestinationInput{}
}
output = &CreateApiDestinationOutput{}
req = c.newRequest(op, input, output)
return
}
// CreateApiDestination API operation for Amazon CloudWatch Events.
//
// Creates an API destination, which is an HTTP invocation endpoint configured
// as a target for events.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation CreateApiDestination for usage and error information.
//
// Returned Error Types:
//
// - ResourceAlreadyExistsException
// The resource you are trying to create already exists.
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - LimitExceededException
// The request failed because it attempted to create resource beyond the allowed
// service quota.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) CreateApiDestination(input *CreateApiDestinationInput) (*CreateApiDestinationOutput, error) {
req, out := c.CreateApiDestinationRequest(input)
return out, req.Send()
}
// CreateApiDestinationWithContext is the same as CreateApiDestination with the addition of
// the ability to pass a context and additional request options.
//
// See CreateApiDestination for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) CreateApiDestinationWithContext(ctx aws.Context, input *CreateApiDestinationInput, opts ...request.Option) (*CreateApiDestinationOutput, error) {
req, out := c.CreateApiDestinationRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opCreateArchive = "CreateArchive"
// CreateArchiveRequest generates a "aws/request.Request" representing the
// client's request for the CreateArchive operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateArchive for more information on using the CreateArchive
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the CreateArchiveRequest method.
// req, resp := client.CreateArchiveRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) CreateArchiveRequest(input *CreateArchiveInput) (req *request.Request, output *CreateArchiveOutput) {
op := &request.Operation{
Name: opCreateArchive,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &CreateArchiveInput{}
}
output = &CreateArchiveOutput{}
req = c.newRequest(op, input, output)
return
}
// CreateArchive API operation for Amazon CloudWatch Events.
//
// Creates an archive of events with the specified settings. When you create
// an archive, incoming events might not immediately start being sent to the
// archive. Allow a short period of time for changes to take effect. If you
// do not specify a pattern to filter events sent to the archive, all events
// are sent to the archive except replayed events. Replayed events are not sent
// to an archive.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation CreateArchive for usage and error information.
//
// Returned Error Types:
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - ResourceAlreadyExistsException
// The resource you are trying to create already exists.
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - LimitExceededException
// The request failed because it attempted to create resource beyond the allowed
// service quota.
//
// - InvalidEventPatternException
// The event pattern is not valid.
//
// See also, path_to_url
func (c *CloudWatchEvents) CreateArchive(input *CreateArchiveInput) (*CreateArchiveOutput, error) {
req, out := c.CreateArchiveRequest(input)
return out, req.Send()
}
// CreateArchiveWithContext is the same as CreateArchive with the addition of
// the ability to pass a context and additional request options.
//
// See CreateArchive for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) CreateArchiveWithContext(ctx aws.Context, input *CreateArchiveInput, opts ...request.Option) (*CreateArchiveOutput, error) {
req, out := c.CreateArchiveRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opCreateConnection = "CreateConnection"
// CreateConnectionRequest generates a "aws/request.Request" representing the
// client's request for the CreateConnection operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateConnection for more information on using the CreateConnection
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the CreateConnectionRequest method.
// req, resp := client.CreateConnectionRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) CreateConnectionRequest(input *CreateConnectionInput) (req *request.Request, output *CreateConnectionOutput) {
op := &request.Operation{
Name: opCreateConnection,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &CreateConnectionInput{}
}
output = &CreateConnectionOutput{}
req = c.newRequest(op, input, output)
return
}
// CreateConnection API operation for Amazon CloudWatch Events.
//
// Creates a connection. A connection defines the authorization type and credentials
// to use for authorization with an API destination HTTP endpoint.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation CreateConnection for usage and error information.
//
// Returned Error Types:
//
// - ResourceAlreadyExistsException
// The resource you are trying to create already exists.
//
// - LimitExceededException
// The request failed because it attempted to create resource beyond the allowed
// service quota.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) CreateConnection(input *CreateConnectionInput) (*CreateConnectionOutput, error) {
req, out := c.CreateConnectionRequest(input)
return out, req.Send()
}
// CreateConnectionWithContext is the same as CreateConnection with the addition of
// the ability to pass a context and additional request options.
//
// See CreateConnection for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) CreateConnectionWithContext(ctx aws.Context, input *CreateConnectionInput, opts ...request.Option) (*CreateConnectionOutput, error) {
req, out := c.CreateConnectionRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opCreateEventBus = "CreateEventBus"
// CreateEventBusRequest generates a "aws/request.Request" representing the
// client's request for the CreateEventBus operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateEventBus for more information on using the CreateEventBus
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the CreateEventBusRequest method.
// req, resp := client.CreateEventBusRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) CreateEventBusRequest(input *CreateEventBusInput) (req *request.Request, output *CreateEventBusOutput) {
op := &request.Operation{
Name: opCreateEventBus,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &CreateEventBusInput{}
}
output = &CreateEventBusOutput{}
req = c.newRequest(op, input, output)
return
}
// CreateEventBus API operation for Amazon CloudWatch Events.
//
// Creates a new event bus within your account. This can be a custom event bus
// which you can use to receive events from your custom applications and services,
// or it can be a partner event bus which can be matched to a partner event
// source.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation CreateEventBus for usage and error information.
//
// Returned Error Types:
//
// - ResourceAlreadyExistsException
// The resource you are trying to create already exists.
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InvalidStateException
// The specified state is not a valid state for an event source.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - LimitExceededException
// The request failed because it attempted to create resource beyond the allowed
// service quota.
//
// - OperationDisabledException
// The operation you are attempting is not available in this region.
//
// See also, path_to_url
func (c *CloudWatchEvents) CreateEventBus(input *CreateEventBusInput) (*CreateEventBusOutput, error) {
req, out := c.CreateEventBusRequest(input)
return out, req.Send()
}
// CreateEventBusWithContext is the same as CreateEventBus with the addition of
// the ability to pass a context and additional request options.
//
// See CreateEventBus for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) CreateEventBusWithContext(ctx aws.Context, input *CreateEventBusInput, opts ...request.Option) (*CreateEventBusOutput, error) {
req, out := c.CreateEventBusRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opCreatePartnerEventSource = "CreatePartnerEventSource"
// CreatePartnerEventSourceRequest generates a "aws/request.Request" representing the
// client's request for the CreatePartnerEventSource operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreatePartnerEventSource for more information on using the CreatePartnerEventSource
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the CreatePartnerEventSourceRequest method.
// req, resp := client.CreatePartnerEventSourceRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) CreatePartnerEventSourceRequest(input *CreatePartnerEventSourceInput) (req *request.Request, output *CreatePartnerEventSourceOutput) {
op := &request.Operation{
Name: opCreatePartnerEventSource,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &CreatePartnerEventSourceInput{}
}
output = &CreatePartnerEventSourceOutput{}
req = c.newRequest(op, input, output)
return
}
// CreatePartnerEventSource API operation for Amazon CloudWatch Events.
//
// Called by an SaaS partner to create a partner event source. This operation
// is not used by Amazon Web Services customers.
//
// Each partner event source can be used by one Amazon Web Services account
// to create a matching partner event bus in that Amazon Web Services account.
// A SaaS partner must create one partner event source for each Amazon Web Services
// account that wants to receive those event types.
//
// A partner event source creates events based on resources within the SaaS
// partner's service or application.
//
// An Amazon Web Services account that creates a partner event bus that matches
// the partner event source can use that event bus to receive events from the
// partner, and then process them using Amazon Web Services Events rules and
// targets.
//
// Partner event source names follow this format:
//
// partner_name/event_namespace/event_name
//
// partner_name is determined during partner registration and identifies the
// partner to Amazon Web Services customers. event_namespace is determined by
// the partner and is a way for the partner to categorize their events. event_name
// is determined by the partner, and should uniquely identify an event-generating
// resource within the partner system. The combination of event_namespace and
// event_name should help Amazon Web Services customers decide whether to create
// an event bus to receive these events.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation CreatePartnerEventSource for usage and error information.
//
// Returned Error Types:
//
// - ResourceAlreadyExistsException
// The resource you are trying to create already exists.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - LimitExceededException
// The request failed because it attempted to create resource beyond the allowed
// service quota.
//
// - OperationDisabledException
// The operation you are attempting is not available in this region.
//
// See also, path_to_url
func (c *CloudWatchEvents) CreatePartnerEventSource(input *CreatePartnerEventSourceInput) (*CreatePartnerEventSourceOutput, error) {
req, out := c.CreatePartnerEventSourceRequest(input)
return out, req.Send()
}
// CreatePartnerEventSourceWithContext is the same as CreatePartnerEventSource with the addition of
// the ability to pass a context and additional request options.
//
// See CreatePartnerEventSource for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) CreatePartnerEventSourceWithContext(ctx aws.Context, input *CreatePartnerEventSourceInput, opts ...request.Option) (*CreatePartnerEventSourceOutput, error) {
req, out := c.CreatePartnerEventSourceRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDeactivateEventSource = "DeactivateEventSource"
// DeactivateEventSourceRequest generates a "aws/request.Request" representing the
// client's request for the DeactivateEventSource operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeactivateEventSource for more information on using the DeactivateEventSource
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the DeactivateEventSourceRequest method.
// req, resp := client.DeactivateEventSourceRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) DeactivateEventSourceRequest(input *DeactivateEventSourceInput) (req *request.Request, output *DeactivateEventSourceOutput) {
op := &request.Operation{
Name: opDeactivateEventSource,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &DeactivateEventSourceInput{}
}
output = &DeactivateEventSourceOutput{}
req = c.newRequest(op, input, output)
req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
return
}
// DeactivateEventSource API operation for Amazon CloudWatch Events.
//
// You can use this operation to temporarily stop receiving events from the
// specified partner event source. The matching event bus is not deleted.
//
// When you deactivate a partner event source, the source goes into PENDING
// state. If it remains in PENDING state for more than two weeks, it is deleted.
//
// To activate a deactivated partner event source, use ActivateEventSource (path_to_url
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation DeactivateEventSource for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - InvalidStateException
// The specified state is not a valid state for an event source.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - OperationDisabledException
// The operation you are attempting is not available in this region.
//
// See also, path_to_url
func (c *CloudWatchEvents) DeactivateEventSource(input *DeactivateEventSourceInput) (*DeactivateEventSourceOutput, error) {
req, out := c.DeactivateEventSourceRequest(input)
return out, req.Send()
}
// DeactivateEventSourceWithContext is the same as DeactivateEventSource with the addition of
// the ability to pass a context and additional request options.
//
// See DeactivateEventSource for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) DeactivateEventSourceWithContext(ctx aws.Context, input *DeactivateEventSourceInput, opts ...request.Option) (*DeactivateEventSourceOutput, error) {
req, out := c.DeactivateEventSourceRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDeauthorizeConnection = "DeauthorizeConnection"
// DeauthorizeConnectionRequest generates a "aws/request.Request" representing the
// client's request for the DeauthorizeConnection operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeauthorizeConnection for more information on using the DeauthorizeConnection
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the DeauthorizeConnectionRequest method.
// req, resp := client.DeauthorizeConnectionRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) DeauthorizeConnectionRequest(input *DeauthorizeConnectionInput) (req *request.Request, output *DeauthorizeConnectionOutput) {
op := &request.Operation{
Name: opDeauthorizeConnection,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &DeauthorizeConnectionInput{}
}
output = &DeauthorizeConnectionOutput{}
req = c.newRequest(op, input, output)
return
}
// DeauthorizeConnection API operation for Amazon CloudWatch Events.
//
// Removes all authorization parameters from the connection. This lets you remove
// the secret from the connection so you can reuse it without having to create
// a new connection.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation DeauthorizeConnection for usage and error information.
//
// Returned Error Types:
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) DeauthorizeConnection(input *DeauthorizeConnectionInput) (*DeauthorizeConnectionOutput, error) {
req, out := c.DeauthorizeConnectionRequest(input)
return out, req.Send()
}
// DeauthorizeConnectionWithContext is the same as DeauthorizeConnection with the addition of
// the ability to pass a context and additional request options.
//
// See DeauthorizeConnection for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) DeauthorizeConnectionWithContext(ctx aws.Context, input *DeauthorizeConnectionInput, opts ...request.Option) (*DeauthorizeConnectionOutput, error) {
req, out := c.DeauthorizeConnectionRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDeleteApiDestination = "DeleteApiDestination"
// DeleteApiDestinationRequest generates a "aws/request.Request" representing the
// client's request for the DeleteApiDestination operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteApiDestination for more information on using the DeleteApiDestination
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the DeleteApiDestinationRequest method.
// req, resp := client.DeleteApiDestinationRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) DeleteApiDestinationRequest(input *DeleteApiDestinationInput) (req *request.Request, output *DeleteApiDestinationOutput) {
op := &request.Operation{
Name: opDeleteApiDestination,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &DeleteApiDestinationInput{}
}
output = &DeleteApiDestinationOutput{}
req = c.newRequest(op, input, output)
req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
return
}
// DeleteApiDestination API operation for Amazon CloudWatch Events.
//
// Deletes the specified API destination.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation DeleteApiDestination for usage and error information.
//
// Returned Error Types:
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) DeleteApiDestination(input *DeleteApiDestinationInput) (*DeleteApiDestinationOutput, error) {
req, out := c.DeleteApiDestinationRequest(input)
return out, req.Send()
}
// DeleteApiDestinationWithContext is the same as DeleteApiDestination with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteApiDestination for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) DeleteApiDestinationWithContext(ctx aws.Context, input *DeleteApiDestinationInput, opts ...request.Option) (*DeleteApiDestinationOutput, error) {
req, out := c.DeleteApiDestinationRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDeleteArchive = "DeleteArchive"
// DeleteArchiveRequest generates a "aws/request.Request" representing the
// client's request for the DeleteArchive operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteArchive for more information on using the DeleteArchive
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the DeleteArchiveRequest method.
// req, resp := client.DeleteArchiveRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) DeleteArchiveRequest(input *DeleteArchiveInput) (req *request.Request, output *DeleteArchiveOutput) {
op := &request.Operation{
Name: opDeleteArchive,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &DeleteArchiveInput{}
}
output = &DeleteArchiveOutput{}
req = c.newRequest(op, input, output)
req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
return
}
// DeleteArchive API operation for Amazon CloudWatch Events.
//
// Deletes the specified archive.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation DeleteArchive for usage and error information.
//
// Returned Error Types:
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) DeleteArchive(input *DeleteArchiveInput) (*DeleteArchiveOutput, error) {
req, out := c.DeleteArchiveRequest(input)
return out, req.Send()
}
// DeleteArchiveWithContext is the same as DeleteArchive with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteArchive for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) DeleteArchiveWithContext(ctx aws.Context, input *DeleteArchiveInput, opts ...request.Option) (*DeleteArchiveOutput, error) {
req, out := c.DeleteArchiveRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDeleteConnection = "DeleteConnection"
// DeleteConnectionRequest generates a "aws/request.Request" representing the
// client's request for the DeleteConnection operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteConnection for more information on using the DeleteConnection
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the DeleteConnectionRequest method.
// req, resp := client.DeleteConnectionRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) DeleteConnectionRequest(input *DeleteConnectionInput) (req *request.Request, output *DeleteConnectionOutput) {
op := &request.Operation{
Name: opDeleteConnection,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &DeleteConnectionInput{}
}
output = &DeleteConnectionOutput{}
req = c.newRequest(op, input, output)
return
}
// DeleteConnection API operation for Amazon CloudWatch Events.
//
// Deletes a connection.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation DeleteConnection for usage and error information.
//
// Returned Error Types:
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) DeleteConnection(input *DeleteConnectionInput) (*DeleteConnectionOutput, error) {
req, out := c.DeleteConnectionRequest(input)
return out, req.Send()
}
// DeleteConnectionWithContext is the same as DeleteConnection with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteConnection for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) DeleteConnectionWithContext(ctx aws.Context, input *DeleteConnectionInput, opts ...request.Option) (*DeleteConnectionOutput, error) {
req, out := c.DeleteConnectionRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDeleteEventBus = "DeleteEventBus"
// DeleteEventBusRequest generates a "aws/request.Request" representing the
// client's request for the DeleteEventBus operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteEventBus for more information on using the DeleteEventBus
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the DeleteEventBusRequest method.
// req, resp := client.DeleteEventBusRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) DeleteEventBusRequest(input *DeleteEventBusInput) (req *request.Request, output *DeleteEventBusOutput) {
op := &request.Operation{
Name: opDeleteEventBus,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &DeleteEventBusInput{}
}
output = &DeleteEventBusOutput{}
req = c.newRequest(op, input, output)
req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
return
}
// DeleteEventBus API operation for Amazon CloudWatch Events.
//
// Deletes the specified custom event bus or partner event bus. All rules associated
// with this event bus need to be deleted. You can't delete your account's default
// event bus.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation DeleteEventBus for usage and error information.
//
// Returned Error Types:
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// See also, path_to_url
func (c *CloudWatchEvents) DeleteEventBus(input *DeleteEventBusInput) (*DeleteEventBusOutput, error) {
req, out := c.DeleteEventBusRequest(input)
return out, req.Send()
}
// DeleteEventBusWithContext is the same as DeleteEventBus with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteEventBus for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) DeleteEventBusWithContext(ctx aws.Context, input *DeleteEventBusInput, opts ...request.Option) (*DeleteEventBusOutput, error) {
req, out := c.DeleteEventBusRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDeletePartnerEventSource = "DeletePartnerEventSource"
// DeletePartnerEventSourceRequest generates a "aws/request.Request" representing the
// client's request for the DeletePartnerEventSource operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeletePartnerEventSource for more information on using the DeletePartnerEventSource
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the DeletePartnerEventSourceRequest method.
// req, resp := client.DeletePartnerEventSourceRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) DeletePartnerEventSourceRequest(input *DeletePartnerEventSourceInput) (req *request.Request, output *DeletePartnerEventSourceOutput) {
op := &request.Operation{
Name: opDeletePartnerEventSource,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &DeletePartnerEventSourceInput{}
}
output = &DeletePartnerEventSourceOutput{}
req = c.newRequest(op, input, output)
req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
return
}
// DeletePartnerEventSource API operation for Amazon CloudWatch Events.
//
// This operation is used by SaaS partners to delete a partner event source.
// This operation is not used by Amazon Web Services customers.
//
// When you delete an event source, the status of the corresponding partner
// event bus in the Amazon Web Services customer account becomes DELETED.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation DeletePartnerEventSource for usage and error information.
//
// Returned Error Types:
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - OperationDisabledException
// The operation you are attempting is not available in this region.
//
// See also, path_to_url
func (c *CloudWatchEvents) DeletePartnerEventSource(input *DeletePartnerEventSourceInput) (*DeletePartnerEventSourceOutput, error) {
req, out := c.DeletePartnerEventSourceRequest(input)
return out, req.Send()
}
// DeletePartnerEventSourceWithContext is the same as DeletePartnerEventSource with the addition of
// the ability to pass a context and additional request options.
//
// See DeletePartnerEventSource for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) DeletePartnerEventSourceWithContext(ctx aws.Context, input *DeletePartnerEventSourceInput, opts ...request.Option) (*DeletePartnerEventSourceOutput, error) {
req, out := c.DeletePartnerEventSourceRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDeleteRule = "DeleteRule"
// DeleteRuleRequest generates a "aws/request.Request" representing the
// client's request for the DeleteRule operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteRule for more information on using the DeleteRule
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the DeleteRuleRequest method.
// req, resp := client.DeleteRuleRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) DeleteRuleRequest(input *DeleteRuleInput) (req *request.Request, output *DeleteRuleOutput) {
op := &request.Operation{
Name: opDeleteRule,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &DeleteRuleInput{}
}
output = &DeleteRuleOutput{}
req = c.newRequest(op, input, output)
req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
return
}
// DeleteRule API operation for Amazon CloudWatch Events.
//
// Deletes the specified rule.
//
// Before you can delete the rule, you must remove all targets, using RemoveTargets
// (path_to_url
//
// When you delete a rule, incoming events might continue to match to the deleted
// rule. Allow a short period of time for changes to take effect.
//
// If you call delete rule multiple times for the same rule, all calls will
// succeed. When you call delete rule for a non-existent custom eventbus, ResourceNotFoundException
// is returned.
//
// Managed rules are rules created and managed by another Amazon Web Services
// service on your behalf. These rules are created by those other Amazon Web
// Services services to support functionality in those services. You can delete
// these rules using the Force option, but you should do so only if you are
// sure the other service is not still using that rule.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation DeleteRule for usage and error information.
//
// Returned Error Types:
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - ManagedRuleException
// This rule was created by an Amazon Web Services service on behalf of your
// account. It is managed by that service. If you see this error in response
// to DeleteRule or RemoveTargets, you can use the Force parameter in those
// calls to delete the rule or remove targets from the rule. You cannot modify
// these managed rules by using DisableRule, EnableRule, PutTargets, PutRule,
// TagResource, or UntagResource.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// See also, path_to_url
func (c *CloudWatchEvents) DeleteRule(input *DeleteRuleInput) (*DeleteRuleOutput, error) {
req, out := c.DeleteRuleRequest(input)
return out, req.Send()
}
// DeleteRuleWithContext is the same as DeleteRule with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteRule for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) DeleteRuleWithContext(ctx aws.Context, input *DeleteRuleInput, opts ...request.Option) (*DeleteRuleOutput, error) {
req, out := c.DeleteRuleRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDescribeApiDestination = "DescribeApiDestination"
// DescribeApiDestinationRequest generates a "aws/request.Request" representing the
// client's request for the DescribeApiDestination operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeApiDestination for more information on using the DescribeApiDestination
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the DescribeApiDestinationRequest method.
// req, resp := client.DescribeApiDestinationRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) DescribeApiDestinationRequest(input *DescribeApiDestinationInput) (req *request.Request, output *DescribeApiDestinationOutput) {
op := &request.Operation{
Name: opDescribeApiDestination,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &DescribeApiDestinationInput{}
}
output = &DescribeApiDestinationOutput{}
req = c.newRequest(op, input, output)
return
}
// DescribeApiDestination API operation for Amazon CloudWatch Events.
//
// Retrieves details about an API destination.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation DescribeApiDestination for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) DescribeApiDestination(input *DescribeApiDestinationInput) (*DescribeApiDestinationOutput, error) {
req, out := c.DescribeApiDestinationRequest(input)
return out, req.Send()
}
// DescribeApiDestinationWithContext is the same as DescribeApiDestination with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeApiDestination for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) DescribeApiDestinationWithContext(ctx aws.Context, input *DescribeApiDestinationInput, opts ...request.Option) (*DescribeApiDestinationOutput, error) {
req, out := c.DescribeApiDestinationRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDescribeArchive = "DescribeArchive"
// DescribeArchiveRequest generates a "aws/request.Request" representing the
// client's request for the DescribeArchive operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeArchive for more information on using the DescribeArchive
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the DescribeArchiveRequest method.
// req, resp := client.DescribeArchiveRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) DescribeArchiveRequest(input *DescribeArchiveInput) (req *request.Request, output *DescribeArchiveOutput) {
op := &request.Operation{
Name: opDescribeArchive,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &DescribeArchiveInput{}
}
output = &DescribeArchiveOutput{}
req = c.newRequest(op, input, output)
return
}
// DescribeArchive API operation for Amazon CloudWatch Events.
//
// Retrieves details about an archive.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation DescribeArchive for usage and error information.
//
// Returned Error Types:
//
// - ResourceAlreadyExistsException
// The resource you are trying to create already exists.
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) DescribeArchive(input *DescribeArchiveInput) (*DescribeArchiveOutput, error) {
req, out := c.DescribeArchiveRequest(input)
return out, req.Send()
}
// DescribeArchiveWithContext is the same as DescribeArchive with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeArchive for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) DescribeArchiveWithContext(ctx aws.Context, input *DescribeArchiveInput, opts ...request.Option) (*DescribeArchiveOutput, error) {
req, out := c.DescribeArchiveRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDescribeConnection = "DescribeConnection"
// DescribeConnectionRequest generates a "aws/request.Request" representing the
// client's request for the DescribeConnection operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeConnection for more information on using the DescribeConnection
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the DescribeConnectionRequest method.
// req, resp := client.DescribeConnectionRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) DescribeConnectionRequest(input *DescribeConnectionInput) (req *request.Request, output *DescribeConnectionOutput) {
op := &request.Operation{
Name: opDescribeConnection,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &DescribeConnectionInput{}
}
output = &DescribeConnectionOutput{}
req = c.newRequest(op, input, output)
return
}
// DescribeConnection API operation for Amazon CloudWatch Events.
//
// Retrieves details about a connection.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation DescribeConnection for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) DescribeConnection(input *DescribeConnectionInput) (*DescribeConnectionOutput, error) {
req, out := c.DescribeConnectionRequest(input)
return out, req.Send()
}
// DescribeConnectionWithContext is the same as DescribeConnection with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeConnection for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) DescribeConnectionWithContext(ctx aws.Context, input *DescribeConnectionInput, opts ...request.Option) (*DescribeConnectionOutput, error) {
req, out := c.DescribeConnectionRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDescribeEventBus = "DescribeEventBus"
// DescribeEventBusRequest generates a "aws/request.Request" representing the
// client's request for the DescribeEventBus operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeEventBus for more information on using the DescribeEventBus
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the DescribeEventBusRequest method.
// req, resp := client.DescribeEventBusRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) DescribeEventBusRequest(input *DescribeEventBusInput) (req *request.Request, output *DescribeEventBusOutput) {
op := &request.Operation{
Name: opDescribeEventBus,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &DescribeEventBusInput{}
}
output = &DescribeEventBusOutput{}
req = c.newRequest(op, input, output)
return
}
// DescribeEventBus API operation for Amazon CloudWatch Events.
//
// Displays details about an event bus in your account. This can include the
// external Amazon Web Services accounts that are permitted to write events
// to your default event bus, and the associated policy. For custom event buses
// and partner event buses, it displays the name, ARN, policy, state, and creation
// time.
//
// To enable your account to receive events from other accounts on its default
// event bus, use PutPermission (path_to_url
//
// For more information about partner event buses, see CreateEventBus (path_to_url
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation DescribeEventBus for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) DescribeEventBus(input *DescribeEventBusInput) (*DescribeEventBusOutput, error) {
req, out := c.DescribeEventBusRequest(input)
return out, req.Send()
}
// DescribeEventBusWithContext is the same as DescribeEventBus with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeEventBus for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) DescribeEventBusWithContext(ctx aws.Context, input *DescribeEventBusInput, opts ...request.Option) (*DescribeEventBusOutput, error) {
req, out := c.DescribeEventBusRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDescribeEventSource = "DescribeEventSource"
// DescribeEventSourceRequest generates a "aws/request.Request" representing the
// client's request for the DescribeEventSource operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeEventSource for more information on using the DescribeEventSource
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the DescribeEventSourceRequest method.
// req, resp := client.DescribeEventSourceRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) DescribeEventSourceRequest(input *DescribeEventSourceInput) (req *request.Request, output *DescribeEventSourceOutput) {
op := &request.Operation{
Name: opDescribeEventSource,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &DescribeEventSourceInput{}
}
output = &DescribeEventSourceOutput{}
req = c.newRequest(op, input, output)
return
}
// DescribeEventSource API operation for Amazon CloudWatch Events.
//
// This operation lists details about a partner event source that is shared
// with your account.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation DescribeEventSource for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - OperationDisabledException
// The operation you are attempting is not available in this region.
//
// See also, path_to_url
func (c *CloudWatchEvents) DescribeEventSource(input *DescribeEventSourceInput) (*DescribeEventSourceOutput, error) {
req, out := c.DescribeEventSourceRequest(input)
return out, req.Send()
}
// DescribeEventSourceWithContext is the same as DescribeEventSource with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeEventSource for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) DescribeEventSourceWithContext(ctx aws.Context, input *DescribeEventSourceInput, opts ...request.Option) (*DescribeEventSourceOutput, error) {
req, out := c.DescribeEventSourceRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDescribePartnerEventSource = "DescribePartnerEventSource"
// DescribePartnerEventSourceRequest generates a "aws/request.Request" representing the
// client's request for the DescribePartnerEventSource operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribePartnerEventSource for more information on using the DescribePartnerEventSource
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the DescribePartnerEventSourceRequest method.
// req, resp := client.DescribePartnerEventSourceRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) DescribePartnerEventSourceRequest(input *DescribePartnerEventSourceInput) (req *request.Request, output *DescribePartnerEventSourceOutput) {
op := &request.Operation{
Name: opDescribePartnerEventSource,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &DescribePartnerEventSourceInput{}
}
output = &DescribePartnerEventSourceOutput{}
req = c.newRequest(op, input, output)
return
}
// DescribePartnerEventSource API operation for Amazon CloudWatch Events.
//
// An SaaS partner can use this operation to list details about a partner event
// source that they have created. Amazon Web Services customers do not use this
// operation. Instead, Amazon Web Services customers can use DescribeEventSource
// (path_to_url
// to see details about a partner event source that is shared with them.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation DescribePartnerEventSource for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - OperationDisabledException
// The operation you are attempting is not available in this region.
//
// See also, path_to_url
func (c *CloudWatchEvents) DescribePartnerEventSource(input *DescribePartnerEventSourceInput) (*DescribePartnerEventSourceOutput, error) {
req, out := c.DescribePartnerEventSourceRequest(input)
return out, req.Send()
}
// DescribePartnerEventSourceWithContext is the same as DescribePartnerEventSource with the addition of
// the ability to pass a context and additional request options.
//
// See DescribePartnerEventSource for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) DescribePartnerEventSourceWithContext(ctx aws.Context, input *DescribePartnerEventSourceInput, opts ...request.Option) (*DescribePartnerEventSourceOutput, error) {
req, out := c.DescribePartnerEventSourceRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDescribeReplay = "DescribeReplay"
// DescribeReplayRequest generates a "aws/request.Request" representing the
// client's request for the DescribeReplay operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeReplay for more information on using the DescribeReplay
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the DescribeReplayRequest method.
// req, resp := client.DescribeReplayRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) DescribeReplayRequest(input *DescribeReplayInput) (req *request.Request, output *DescribeReplayOutput) {
op := &request.Operation{
Name: opDescribeReplay,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &DescribeReplayInput{}
}
output = &DescribeReplayOutput{}
req = c.newRequest(op, input, output)
return
}
// DescribeReplay API operation for Amazon CloudWatch Events.
//
// Retrieves details about a replay. Use DescribeReplay to determine the progress
// of a running replay. A replay processes events to replay based on the time
// in the event, and replays them using 1 minute intervals. If you use StartReplay
// and specify an EventStartTime and an EventEndTime that covers a 20 minute
// time range, the events are replayed from the first minute of that 20 minute
// range first. Then the events from the second minute are replayed. You can
// use DescribeReplay to determine the progress of a replay. The value returned
// for EventLastReplayedTime indicates the time within the specified time range
// associated with the last event replayed.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation DescribeReplay for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) DescribeReplay(input *DescribeReplayInput) (*DescribeReplayOutput, error) {
req, out := c.DescribeReplayRequest(input)
return out, req.Send()
}
// DescribeReplayWithContext is the same as DescribeReplay with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeReplay for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) DescribeReplayWithContext(ctx aws.Context, input *DescribeReplayInput, opts ...request.Option) (*DescribeReplayOutput, error) {
req, out := c.DescribeReplayRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDescribeRule = "DescribeRule"
// DescribeRuleRequest generates a "aws/request.Request" representing the
// client's request for the DescribeRule operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DescribeRule for more information on using the DescribeRule
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the DescribeRuleRequest method.
// req, resp := client.DescribeRuleRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) DescribeRuleRequest(input *DescribeRuleInput) (req *request.Request, output *DescribeRuleOutput) {
op := &request.Operation{
Name: opDescribeRule,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &DescribeRuleInput{}
}
output = &DescribeRuleOutput{}
req = c.newRequest(op, input, output)
return
}
// DescribeRule API operation for Amazon CloudWatch Events.
//
// Describes the specified rule.
//
// DescribeRule does not list the targets of a rule. To see the targets associated
// with a rule, use ListTargetsByRule (path_to_url
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation DescribeRule for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) DescribeRule(input *DescribeRuleInput) (*DescribeRuleOutput, error) {
req, out := c.DescribeRuleRequest(input)
return out, req.Send()
}
// DescribeRuleWithContext is the same as DescribeRule with the addition of
// the ability to pass a context and additional request options.
//
// See DescribeRule for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) DescribeRuleWithContext(ctx aws.Context, input *DescribeRuleInput, opts ...request.Option) (*DescribeRuleOutput, error) {
req, out := c.DescribeRuleRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDisableRule = "DisableRule"
// DisableRuleRequest generates a "aws/request.Request" representing the
// client's request for the DisableRule operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DisableRule for more information on using the DisableRule
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the DisableRuleRequest method.
// req, resp := client.DisableRuleRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) DisableRuleRequest(input *DisableRuleInput) (req *request.Request, output *DisableRuleOutput) {
op := &request.Operation{
Name: opDisableRule,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &DisableRuleInput{}
}
output = &DisableRuleOutput{}
req = c.newRequest(op, input, output)
req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
return
}
// DisableRule API operation for Amazon CloudWatch Events.
//
// Disables the specified rule. A disabled rule won't match any events, and
// won't self-trigger if it has a schedule expression.
//
// When you disable a rule, incoming events might continue to match to the disabled
// rule. Allow a short period of time for changes to take effect.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation DisableRule for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - ManagedRuleException
// This rule was created by an Amazon Web Services service on behalf of your
// account. It is managed by that service. If you see this error in response
// to DeleteRule or RemoveTargets, you can use the Force parameter in those
// calls to delete the rule or remove targets from the rule. You cannot modify
// these managed rules by using DisableRule, EnableRule, PutTargets, PutRule,
// TagResource, or UntagResource.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) DisableRule(input *DisableRuleInput) (*DisableRuleOutput, error) {
req, out := c.DisableRuleRequest(input)
return out, req.Send()
}
// DisableRuleWithContext is the same as DisableRule with the addition of
// the ability to pass a context and additional request options.
//
// See DisableRule for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) DisableRuleWithContext(ctx aws.Context, input *DisableRuleInput, opts ...request.Option) (*DisableRuleOutput, error) {
req, out := c.DisableRuleRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opEnableRule = "EnableRule"
// EnableRuleRequest generates a "aws/request.Request" representing the
// client's request for the EnableRule operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See EnableRule for more information on using the EnableRule
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the EnableRuleRequest method.
// req, resp := client.EnableRuleRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) EnableRuleRequest(input *EnableRuleInput) (req *request.Request, output *EnableRuleOutput) {
op := &request.Operation{
Name: opEnableRule,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &EnableRuleInput{}
}
output = &EnableRuleOutput{}
req = c.newRequest(op, input, output)
req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
return
}
// EnableRule API operation for Amazon CloudWatch Events.
//
// Enables the specified rule. If the rule does not exist, the operation fails.
//
// When you enable a rule, incoming events might not immediately start matching
// to a newly enabled rule. Allow a short period of time for changes to take
// effect.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation EnableRule for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - ManagedRuleException
// This rule was created by an Amazon Web Services service on behalf of your
// account. It is managed by that service. If you see this error in response
// to DeleteRule or RemoveTargets, you can use the Force parameter in those
// calls to delete the rule or remove targets from the rule. You cannot modify
// these managed rules by using DisableRule, EnableRule, PutTargets, PutRule,
// TagResource, or UntagResource.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) EnableRule(input *EnableRuleInput) (*EnableRuleOutput, error) {
req, out := c.EnableRuleRequest(input)
return out, req.Send()
}
// EnableRuleWithContext is the same as EnableRule with the addition of
// the ability to pass a context and additional request options.
//
// See EnableRule for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) EnableRuleWithContext(ctx aws.Context, input *EnableRuleInput, opts ...request.Option) (*EnableRuleOutput, error) {
req, out := c.EnableRuleRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opListApiDestinations = "ListApiDestinations"
// ListApiDestinationsRequest generates a "aws/request.Request" representing the
// client's request for the ListApiDestinations operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListApiDestinations for more information on using the ListApiDestinations
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the ListApiDestinationsRequest method.
// req, resp := client.ListApiDestinationsRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) ListApiDestinationsRequest(input *ListApiDestinationsInput) (req *request.Request, output *ListApiDestinationsOutput) {
op := &request.Operation{
Name: opListApiDestinations,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &ListApiDestinationsInput{}
}
output = &ListApiDestinationsOutput{}
req = c.newRequest(op, input, output)
return
}
// ListApiDestinations API operation for Amazon CloudWatch Events.
//
// Retrieves a list of API destination in the account in the current Region.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation ListApiDestinations for usage and error information.
//
// Returned Error Types:
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) ListApiDestinations(input *ListApiDestinationsInput) (*ListApiDestinationsOutput, error) {
req, out := c.ListApiDestinationsRequest(input)
return out, req.Send()
}
// ListApiDestinationsWithContext is the same as ListApiDestinations with the addition of
// the ability to pass a context and additional request options.
//
// See ListApiDestinations for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) ListApiDestinationsWithContext(ctx aws.Context, input *ListApiDestinationsInput, opts ...request.Option) (*ListApiDestinationsOutput, error) {
req, out := c.ListApiDestinationsRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opListArchives = "ListArchives"
// ListArchivesRequest generates a "aws/request.Request" representing the
// client's request for the ListArchives operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListArchives for more information on using the ListArchives
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the ListArchivesRequest method.
// req, resp := client.ListArchivesRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) ListArchivesRequest(input *ListArchivesInput) (req *request.Request, output *ListArchivesOutput) {
op := &request.Operation{
Name: opListArchives,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &ListArchivesInput{}
}
output = &ListArchivesOutput{}
req = c.newRequest(op, input, output)
return
}
// ListArchives API operation for Amazon CloudWatch Events.
//
// Lists your archives. You can either list all the archives or you can provide
// a prefix to match to the archive names. Filter parameters are exclusive.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation ListArchives for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) ListArchives(input *ListArchivesInput) (*ListArchivesOutput, error) {
req, out := c.ListArchivesRequest(input)
return out, req.Send()
}
// ListArchivesWithContext is the same as ListArchives with the addition of
// the ability to pass a context and additional request options.
//
// See ListArchives for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) ListArchivesWithContext(ctx aws.Context, input *ListArchivesInput, opts ...request.Option) (*ListArchivesOutput, error) {
req, out := c.ListArchivesRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opListConnections = "ListConnections"
// ListConnectionsRequest generates a "aws/request.Request" representing the
// client's request for the ListConnections operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListConnections for more information on using the ListConnections
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the ListConnectionsRequest method.
// req, resp := client.ListConnectionsRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) ListConnectionsRequest(input *ListConnectionsInput) (req *request.Request, output *ListConnectionsOutput) {
op := &request.Operation{
Name: opListConnections,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &ListConnectionsInput{}
}
output = &ListConnectionsOutput{}
req = c.newRequest(op, input, output)
return
}
// ListConnections API operation for Amazon CloudWatch Events.
//
// Retrieves a list of connections from the account.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation ListConnections for usage and error information.
//
// Returned Error Types:
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) ListConnections(input *ListConnectionsInput) (*ListConnectionsOutput, error) {
req, out := c.ListConnectionsRequest(input)
return out, req.Send()
}
// ListConnectionsWithContext is the same as ListConnections with the addition of
// the ability to pass a context and additional request options.
//
// See ListConnections for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) ListConnectionsWithContext(ctx aws.Context, input *ListConnectionsInput, opts ...request.Option) (*ListConnectionsOutput, error) {
req, out := c.ListConnectionsRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opListEventBuses = "ListEventBuses"
// ListEventBusesRequest generates a "aws/request.Request" representing the
// client's request for the ListEventBuses operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListEventBuses for more information on using the ListEventBuses
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the ListEventBusesRequest method.
// req, resp := client.ListEventBusesRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) ListEventBusesRequest(input *ListEventBusesInput) (req *request.Request, output *ListEventBusesOutput) {
op := &request.Operation{
Name: opListEventBuses,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &ListEventBusesInput{}
}
output = &ListEventBusesOutput{}
req = c.newRequest(op, input, output)
return
}
// ListEventBuses API operation for Amazon CloudWatch Events.
//
// Lists all the event buses in your account, including the default event bus,
// custom event buses, and partner event buses.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation ListEventBuses for usage and error information.
//
// Returned Error Types:
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) ListEventBuses(input *ListEventBusesInput) (*ListEventBusesOutput, error) {
req, out := c.ListEventBusesRequest(input)
return out, req.Send()
}
// ListEventBusesWithContext is the same as ListEventBuses with the addition of
// the ability to pass a context and additional request options.
//
// See ListEventBuses for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) ListEventBusesWithContext(ctx aws.Context, input *ListEventBusesInput, opts ...request.Option) (*ListEventBusesOutput, error) {
req, out := c.ListEventBusesRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opListEventSources = "ListEventSources"
// ListEventSourcesRequest generates a "aws/request.Request" representing the
// client's request for the ListEventSources operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListEventSources for more information on using the ListEventSources
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the ListEventSourcesRequest method.
// req, resp := client.ListEventSourcesRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) ListEventSourcesRequest(input *ListEventSourcesInput) (req *request.Request, output *ListEventSourcesOutput) {
op := &request.Operation{
Name: opListEventSources,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &ListEventSourcesInput{}
}
output = &ListEventSourcesOutput{}
req = c.newRequest(op, input, output)
return
}
// ListEventSources API operation for Amazon CloudWatch Events.
//
// You can use this to see all the partner event sources that have been shared
// with your Amazon Web Services account. For more information about partner
// event sources, see CreateEventBus (path_to_url
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation ListEventSources for usage and error information.
//
// Returned Error Types:
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - OperationDisabledException
// The operation you are attempting is not available in this region.
//
// See also, path_to_url
func (c *CloudWatchEvents) ListEventSources(input *ListEventSourcesInput) (*ListEventSourcesOutput, error) {
req, out := c.ListEventSourcesRequest(input)
return out, req.Send()
}
// ListEventSourcesWithContext is the same as ListEventSources with the addition of
// the ability to pass a context and additional request options.
//
// See ListEventSources for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) ListEventSourcesWithContext(ctx aws.Context, input *ListEventSourcesInput, opts ...request.Option) (*ListEventSourcesOutput, error) {
req, out := c.ListEventSourcesRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opListPartnerEventSourceAccounts = "ListPartnerEventSourceAccounts"
// ListPartnerEventSourceAccountsRequest generates a "aws/request.Request" representing the
// client's request for the ListPartnerEventSourceAccounts operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListPartnerEventSourceAccounts for more information on using the ListPartnerEventSourceAccounts
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the ListPartnerEventSourceAccountsRequest method.
// req, resp := client.ListPartnerEventSourceAccountsRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) ListPartnerEventSourceAccountsRequest(input *ListPartnerEventSourceAccountsInput) (req *request.Request, output *ListPartnerEventSourceAccountsOutput) {
op := &request.Operation{
Name: opListPartnerEventSourceAccounts,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &ListPartnerEventSourceAccountsInput{}
}
output = &ListPartnerEventSourceAccountsOutput{}
req = c.newRequest(op, input, output)
return
}
// ListPartnerEventSourceAccounts API operation for Amazon CloudWatch Events.
//
// An SaaS partner can use this operation to display the Amazon Web Services
// account ID that a particular partner event source name is associated with.
// This operation is not used by Amazon Web Services customers.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation ListPartnerEventSourceAccounts for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - OperationDisabledException
// The operation you are attempting is not available in this region.
//
// See also, path_to_url
func (c *CloudWatchEvents) ListPartnerEventSourceAccounts(input *ListPartnerEventSourceAccountsInput) (*ListPartnerEventSourceAccountsOutput, error) {
req, out := c.ListPartnerEventSourceAccountsRequest(input)
return out, req.Send()
}
// ListPartnerEventSourceAccountsWithContext is the same as ListPartnerEventSourceAccounts with the addition of
// the ability to pass a context and additional request options.
//
// See ListPartnerEventSourceAccounts for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) ListPartnerEventSourceAccountsWithContext(ctx aws.Context, input *ListPartnerEventSourceAccountsInput, opts ...request.Option) (*ListPartnerEventSourceAccountsOutput, error) {
req, out := c.ListPartnerEventSourceAccountsRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opListPartnerEventSources = "ListPartnerEventSources"
// ListPartnerEventSourcesRequest generates a "aws/request.Request" representing the
// client's request for the ListPartnerEventSources operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListPartnerEventSources for more information on using the ListPartnerEventSources
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the ListPartnerEventSourcesRequest method.
// req, resp := client.ListPartnerEventSourcesRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) ListPartnerEventSourcesRequest(input *ListPartnerEventSourcesInput) (req *request.Request, output *ListPartnerEventSourcesOutput) {
op := &request.Operation{
Name: opListPartnerEventSources,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &ListPartnerEventSourcesInput{}
}
output = &ListPartnerEventSourcesOutput{}
req = c.newRequest(op, input, output)
return
}
// ListPartnerEventSources API operation for Amazon CloudWatch Events.
//
// An SaaS partner can use this operation to list all the partner event source
// names that they have created. This operation is not used by Amazon Web Services
// customers.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation ListPartnerEventSources for usage and error information.
//
// Returned Error Types:
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - OperationDisabledException
// The operation you are attempting is not available in this region.
//
// See also, path_to_url
func (c *CloudWatchEvents) ListPartnerEventSources(input *ListPartnerEventSourcesInput) (*ListPartnerEventSourcesOutput, error) {
req, out := c.ListPartnerEventSourcesRequest(input)
return out, req.Send()
}
// ListPartnerEventSourcesWithContext is the same as ListPartnerEventSources with the addition of
// the ability to pass a context and additional request options.
//
// See ListPartnerEventSources for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) ListPartnerEventSourcesWithContext(ctx aws.Context, input *ListPartnerEventSourcesInput, opts ...request.Option) (*ListPartnerEventSourcesOutput, error) {
req, out := c.ListPartnerEventSourcesRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opListReplays = "ListReplays"
// ListReplaysRequest generates a "aws/request.Request" representing the
// client's request for the ListReplays operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListReplays for more information on using the ListReplays
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the ListReplaysRequest method.
// req, resp := client.ListReplaysRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) ListReplaysRequest(input *ListReplaysInput) (req *request.Request, output *ListReplaysOutput) {
op := &request.Operation{
Name: opListReplays,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &ListReplaysInput{}
}
output = &ListReplaysOutput{}
req = c.newRequest(op, input, output)
return
}
// ListReplays API operation for Amazon CloudWatch Events.
//
// Lists your replays. You can either list all the replays or you can provide
// a prefix to match to the replay names. Filter parameters are exclusive.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation ListReplays for usage and error information.
//
// Returned Error Types:
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) ListReplays(input *ListReplaysInput) (*ListReplaysOutput, error) {
req, out := c.ListReplaysRequest(input)
return out, req.Send()
}
// ListReplaysWithContext is the same as ListReplays with the addition of
// the ability to pass a context and additional request options.
//
// See ListReplays for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) ListReplaysWithContext(ctx aws.Context, input *ListReplaysInput, opts ...request.Option) (*ListReplaysOutput, error) {
req, out := c.ListReplaysRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opListRuleNamesByTarget = "ListRuleNamesByTarget"
// ListRuleNamesByTargetRequest generates a "aws/request.Request" representing the
// client's request for the ListRuleNamesByTarget operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListRuleNamesByTarget for more information on using the ListRuleNamesByTarget
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the ListRuleNamesByTargetRequest method.
// req, resp := client.ListRuleNamesByTargetRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) ListRuleNamesByTargetRequest(input *ListRuleNamesByTargetInput) (req *request.Request, output *ListRuleNamesByTargetOutput) {
op := &request.Operation{
Name: opListRuleNamesByTarget,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &ListRuleNamesByTargetInput{}
}
output = &ListRuleNamesByTargetOutput{}
req = c.newRequest(op, input, output)
return
}
// ListRuleNamesByTarget API operation for Amazon CloudWatch Events.
//
// Lists the rules for the specified target. You can see which of the rules
// in Amazon EventBridge can invoke a specific target in your account.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation ListRuleNamesByTarget for usage and error information.
//
// Returned Error Types:
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// See also, path_to_url
func (c *CloudWatchEvents) ListRuleNamesByTarget(input *ListRuleNamesByTargetInput) (*ListRuleNamesByTargetOutput, error) {
req, out := c.ListRuleNamesByTargetRequest(input)
return out, req.Send()
}
// ListRuleNamesByTargetWithContext is the same as ListRuleNamesByTarget with the addition of
// the ability to pass a context and additional request options.
//
// See ListRuleNamesByTarget for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) ListRuleNamesByTargetWithContext(ctx aws.Context, input *ListRuleNamesByTargetInput, opts ...request.Option) (*ListRuleNamesByTargetOutput, error) {
req, out := c.ListRuleNamesByTargetRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opListRules = "ListRules"
// ListRulesRequest generates a "aws/request.Request" representing the
// client's request for the ListRules operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListRules for more information on using the ListRules
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the ListRulesRequest method.
// req, resp := client.ListRulesRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) ListRulesRequest(input *ListRulesInput) (req *request.Request, output *ListRulesOutput) {
op := &request.Operation{
Name: opListRules,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &ListRulesInput{}
}
output = &ListRulesOutput{}
req = c.newRequest(op, input, output)
return
}
// ListRules API operation for Amazon CloudWatch Events.
//
// Lists your Amazon EventBridge rules. You can either list all the rules or
// you can provide a prefix to match to the rule names.
//
// ListRules does not list the targets of a rule. To see the targets associated
// with a rule, use ListTargetsByRule (path_to_url
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation ListRules for usage and error information.
//
// Returned Error Types:
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// See also, path_to_url
func (c *CloudWatchEvents) ListRules(input *ListRulesInput) (*ListRulesOutput, error) {
req, out := c.ListRulesRequest(input)
return out, req.Send()
}
// ListRulesWithContext is the same as ListRules with the addition of
// the ability to pass a context and additional request options.
//
// See ListRules for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) ListRulesWithContext(ctx aws.Context, input *ListRulesInput, opts ...request.Option) (*ListRulesOutput, error) {
req, out := c.ListRulesRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opListTagsForResource = "ListTagsForResource"
// ListTagsForResourceRequest generates a "aws/request.Request" representing the
// client's request for the ListTagsForResource operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListTagsForResource for more information on using the ListTagsForResource
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the ListTagsForResourceRequest method.
// req, resp := client.ListTagsForResourceRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) ListTagsForResourceRequest(input *ListTagsForResourceInput) (req *request.Request, output *ListTagsForResourceOutput) {
op := &request.Operation{
Name: opListTagsForResource,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &ListTagsForResourceInput{}
}
output = &ListTagsForResourceOutput{}
req = c.newRequest(op, input, output)
return
}
// ListTagsForResource API operation for Amazon CloudWatch Events.
//
// Displays the tags associated with an EventBridge resource. In EventBridge,
// rules and event buses can be tagged.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation ListTagsForResource for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) ListTagsForResource(input *ListTagsForResourceInput) (*ListTagsForResourceOutput, error) {
req, out := c.ListTagsForResourceRequest(input)
return out, req.Send()
}
// ListTagsForResourceWithContext is the same as ListTagsForResource with the addition of
// the ability to pass a context and additional request options.
//
// See ListTagsForResource for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) ListTagsForResourceWithContext(ctx aws.Context, input *ListTagsForResourceInput, opts ...request.Option) (*ListTagsForResourceOutput, error) {
req, out := c.ListTagsForResourceRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opListTargetsByRule = "ListTargetsByRule"
// ListTargetsByRuleRequest generates a "aws/request.Request" representing the
// client's request for the ListTargetsByRule operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See ListTargetsByRule for more information on using the ListTargetsByRule
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the ListTargetsByRuleRequest method.
// req, resp := client.ListTargetsByRuleRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) ListTargetsByRuleRequest(input *ListTargetsByRuleInput) (req *request.Request, output *ListTargetsByRuleOutput) {
op := &request.Operation{
Name: opListTargetsByRule,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &ListTargetsByRuleInput{}
}
output = &ListTargetsByRuleOutput{}
req = c.newRequest(op, input, output)
return
}
// ListTargetsByRule API operation for Amazon CloudWatch Events.
//
// Lists the targets assigned to the specified rule.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation ListTargetsByRule for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) ListTargetsByRule(input *ListTargetsByRuleInput) (*ListTargetsByRuleOutput, error) {
req, out := c.ListTargetsByRuleRequest(input)
return out, req.Send()
}
// ListTargetsByRuleWithContext is the same as ListTargetsByRule with the addition of
// the ability to pass a context and additional request options.
//
// See ListTargetsByRule for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) ListTargetsByRuleWithContext(ctx aws.Context, input *ListTargetsByRuleInput, opts ...request.Option) (*ListTargetsByRuleOutput, error) {
req, out := c.ListTargetsByRuleRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opPutEvents = "PutEvents"
// PutEventsRequest generates a "aws/request.Request" representing the
// client's request for the PutEvents operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See PutEvents for more information on using the PutEvents
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the PutEventsRequest method.
// req, resp := client.PutEventsRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) PutEventsRequest(input *PutEventsInput) (req *request.Request, output *PutEventsOutput) {
op := &request.Operation{
Name: opPutEvents,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &PutEventsInput{}
}
output = &PutEventsOutput{}
req = c.newRequest(op, input, output)
return
}
// PutEvents API operation for Amazon CloudWatch Events.
//
// Sends custom events to Amazon EventBridge so that they can be matched to
// rules.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation PutEvents for usage and error information.
//
// Returned Error Types:
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) PutEvents(input *PutEventsInput) (*PutEventsOutput, error) {
req, out := c.PutEventsRequest(input)
return out, req.Send()
}
// PutEventsWithContext is the same as PutEvents with the addition of
// the ability to pass a context and additional request options.
//
// See PutEvents for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) PutEventsWithContext(ctx aws.Context, input *PutEventsInput, opts ...request.Option) (*PutEventsOutput, error) {
req, out := c.PutEventsRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opPutPartnerEvents = "PutPartnerEvents"
// PutPartnerEventsRequest generates a "aws/request.Request" representing the
// client's request for the PutPartnerEvents operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See PutPartnerEvents for more information on using the PutPartnerEvents
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the PutPartnerEventsRequest method.
// req, resp := client.PutPartnerEventsRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) PutPartnerEventsRequest(input *PutPartnerEventsInput) (req *request.Request, output *PutPartnerEventsOutput) {
op := &request.Operation{
Name: opPutPartnerEvents,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &PutPartnerEventsInput{}
}
output = &PutPartnerEventsOutput{}
req = c.newRequest(op, input, output)
return
}
// PutPartnerEvents API operation for Amazon CloudWatch Events.
//
// This is used by SaaS partners to write events to a customer's partner event
// bus. Amazon Web Services customers do not use this operation.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation PutPartnerEvents for usage and error information.
//
// Returned Error Types:
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - OperationDisabledException
// The operation you are attempting is not available in this region.
//
// See also, path_to_url
func (c *CloudWatchEvents) PutPartnerEvents(input *PutPartnerEventsInput) (*PutPartnerEventsOutput, error) {
req, out := c.PutPartnerEventsRequest(input)
return out, req.Send()
}
// PutPartnerEventsWithContext is the same as PutPartnerEvents with the addition of
// the ability to pass a context and additional request options.
//
// See PutPartnerEvents for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) PutPartnerEventsWithContext(ctx aws.Context, input *PutPartnerEventsInput, opts ...request.Option) (*PutPartnerEventsOutput, error) {
req, out := c.PutPartnerEventsRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opPutPermission = "PutPermission"
// PutPermissionRequest generates a "aws/request.Request" representing the
// client's request for the PutPermission operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See PutPermission for more information on using the PutPermission
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the PutPermissionRequest method.
// req, resp := client.PutPermissionRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) PutPermissionRequest(input *PutPermissionInput) (req *request.Request, output *PutPermissionOutput) {
op := &request.Operation{
Name: opPutPermission,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &PutPermissionInput{}
}
output = &PutPermissionOutput{}
req = c.newRequest(op, input, output)
req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
return
}
// PutPermission API operation for Amazon CloudWatch Events.
//
// Running PutPermission permits the specified Amazon Web Services account or
// Amazon Web Services organization to put events to the specified event bus.
// Amazon EventBridge (CloudWatch Events) rules in your account are triggered
// by these events arriving to an event bus in your account.
//
// For another account to send events to your account, that external account
// must have an EventBridge rule with your account's event bus as a target.
//
// To enable multiple Amazon Web Services accounts to put events to your event
// bus, run PutPermission once for each of these accounts. Or, if all the accounts
// are members of the same Amazon Web Services organization, you can run PutPermission
// once specifying Principal as "*" and specifying the Amazon Web Services organization
// ID in Condition, to grant permissions to all accounts in that organization.
//
// If you grant permissions using an organization, then accounts in that organization
// must specify a RoleArn with proper permissions when they use PutTarget to
// add your account's event bus as a target. For more information, see Sending
// and Receiving Events Between Amazon Web Services Accounts (path_to_url
// in the Amazon EventBridge User Guide.
//
// The permission policy on the event bus cannot exceed 10 KB in size.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation PutPermission for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - PolicyLengthExceededException
// The event bus policy is too long. For more information, see the limits.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - OperationDisabledException
// The operation you are attempting is not available in this region.
//
// See also, path_to_url
func (c *CloudWatchEvents) PutPermission(input *PutPermissionInput) (*PutPermissionOutput, error) {
req, out := c.PutPermissionRequest(input)
return out, req.Send()
}
// PutPermissionWithContext is the same as PutPermission with the addition of
// the ability to pass a context and additional request options.
//
// See PutPermission for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) PutPermissionWithContext(ctx aws.Context, input *PutPermissionInput, opts ...request.Option) (*PutPermissionOutput, error) {
req, out := c.PutPermissionRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opPutRule = "PutRule"
// PutRuleRequest generates a "aws/request.Request" representing the
// client's request for the PutRule operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See PutRule for more information on using the PutRule
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the PutRuleRequest method.
// req, resp := client.PutRuleRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) PutRuleRequest(input *PutRuleInput) (req *request.Request, output *PutRuleOutput) {
op := &request.Operation{
Name: opPutRule,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &PutRuleInput{}
}
output = &PutRuleOutput{}
req = c.newRequest(op, input, output)
return
}
// PutRule API operation for Amazon CloudWatch Events.
//
// Creates or updates the specified rule. Rules are enabled by default, or based
// on value of the state. You can disable a rule using DisableRule (path_to_url
//
// A single rule watches for events from a single event bus. Events generated
// by Amazon Web Services services go to your account's default event bus. Events
// generated by SaaS partner services or applications go to the matching partner
// event bus. If you have custom applications or services, you can specify whether
// their events go to your default event bus or a custom event bus that you
// have created. For more information, see CreateEventBus (path_to_url
//
// If you are updating an existing rule, the rule is replaced with what you
// specify in this PutRule command. If you omit arguments in PutRule, the old
// values for those arguments are not kept. Instead, they are replaced with
// null values.
//
// When you create or update a rule, incoming events might not immediately start
// matching to new or updated rules. Allow a short period of time for changes
// to take effect.
//
// A rule must contain at least an EventPattern or ScheduleExpression. Rules
// with EventPatterns are triggered when a matching event is observed. Rules
// with ScheduleExpressions self-trigger based on the given schedule. A rule
// can have both an EventPattern and a ScheduleExpression, in which case the
// rule triggers on matching events as well as on a schedule.
//
// When you initially create a rule, you can optionally assign one or more tags
// to the rule. Tags can help you organize and categorize your resources. You
// can also use them to scope user permissions, by granting a user permission
// to access or change only rules with certain tag values. To use the PutRule
// operation and assign tags, you must have both the events:PutRule and events:TagResource
// permissions.
//
// If you are updating an existing rule, any tags you specify in the PutRule
// operation are ignored. To update the tags of an existing rule, use TagResource
// (path_to_url
// and UntagResource (path_to_url
//
// Most services in Amazon Web Services treat : or / as the same character in
// Amazon Resource Names (ARNs). However, EventBridge uses an exact match in
// event patterns and rules. Be sure to use the correct ARN characters when
// creating event patterns so that they match the ARN syntax in the event you
// want to match.
//
// In EventBridge, it is possible to create rules that lead to infinite loops,
// where a rule is fired repeatedly. For example, a rule might detect that ACLs
// have changed on an S3 bucket, and trigger software to change them to the
// desired state. If the rule is not written carefully, the subsequent change
// to the ACLs fires the rule again, creating an infinite loop.
//
// To prevent this, write the rules so that the triggered actions do not re-fire
// the same rule. For example, your rule could fire only if ACLs are found to
// be in a bad state, instead of after any change.
//
// An infinite loop can quickly cause higher than expected charges. We recommend
// that you use budgeting, which alerts you when charges exceed your specified
// limit. For more information, see Managing Your Costs with Budgets (path_to_url
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation PutRule for usage and error information.
//
// Returned Error Types:
//
// - InvalidEventPatternException
// The event pattern is not valid.
//
// - LimitExceededException
// The request failed because it attempted to create resource beyond the allowed
// service quota.
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - ManagedRuleException
// This rule was created by an Amazon Web Services service on behalf of your
// account. It is managed by that service. If you see this error in response
// to DeleteRule or RemoveTargets, you can use the Force parameter in those
// calls to delete the rule or remove targets from the rule. You cannot modify
// these managed rules by using DisableRule, EnableRule, PutTargets, PutRule,
// TagResource, or UntagResource.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// See also, path_to_url
func (c *CloudWatchEvents) PutRule(input *PutRuleInput) (*PutRuleOutput, error) {
req, out := c.PutRuleRequest(input)
return out, req.Send()
}
// PutRuleWithContext is the same as PutRule with the addition of
// the ability to pass a context and additional request options.
//
// See PutRule for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) PutRuleWithContext(ctx aws.Context, input *PutRuleInput, opts ...request.Option) (*PutRuleOutput, error) {
req, out := c.PutRuleRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opPutTargets = "PutTargets"
// PutTargetsRequest generates a "aws/request.Request" representing the
// client's request for the PutTargets operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See PutTargets for more information on using the PutTargets
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the PutTargetsRequest method.
// req, resp := client.PutTargetsRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) PutTargetsRequest(input *PutTargetsInput) (req *request.Request, output *PutTargetsOutput) {
op := &request.Operation{
Name: opPutTargets,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &PutTargetsInput{}
}
output = &PutTargetsOutput{}
req = c.newRequest(op, input, output)
return
}
// PutTargets API operation for Amazon CloudWatch Events.
//
// Adds the specified targets to the specified rule, or updates the targets
// if they are already associated with the rule.
//
// Targets are the resources that are invoked when a rule is triggered.
//
// You can configure the following as targets for Events:
//
// - API destination (path_to_url
//
// - Amazon API Gateway REST API endpoints
//
// - API Gateway
//
// - Batch job queue
//
// - CloudWatch Logs group
//
// - CodeBuild project
//
// - CodePipeline
//
// - Amazon EC2 CreateSnapshot API call
//
// - Amazon EC2 RebootInstances API call
//
// - Amazon EC2 StopInstances API call
//
// - Amazon EC2 TerminateInstances API call
//
// - Amazon ECS tasks
//
// - Event bus in a different Amazon Web Services account or Region. You
// can use an event bus in the US East (N. Virginia) us-east-1, US West (Oregon)
// us-west-2, or Europe (Ireland) eu-west-1 Regions as a target for a rule.
//
// - Firehose delivery stream (Kinesis Data Firehose)
//
// - Inspector assessment template (Amazon Inspector)
//
// - Kinesis stream (Kinesis Data Stream)
//
// - Lambda function
//
// - Redshift clusters (Data API statement execution)
//
// - Amazon SNS topic
//
// - Amazon SQS queues (includes FIFO queues
//
// - SSM Automation
//
// - SSM OpsItem
//
// - SSM Run Command
//
// - Step Functions state machines
//
// Creating rules with built-in targets is supported only in the Amazon Web
// Services Management Console. The built-in targets are EC2 CreateSnapshot
// API call, EC2 RebootInstances API call, EC2 StopInstances API call, and EC2
// TerminateInstances API call.
//
// For some target types, PutTargets provides target-specific parameters. If
// the target is a Kinesis data stream, you can optionally specify which shard
// the event goes to by using the KinesisParameters argument. To invoke a command
// on multiple EC2 instances with one rule, you can use the RunCommandParameters
// field.
//
// To be able to make API calls against the resources that you own, Amazon EventBridge
// needs the appropriate permissions. For Lambda and Amazon SNS resources, EventBridge
// relies on resource-based policies. For EC2 instances, Kinesis Data Streams,
// Step Functions state machines and API Gateway REST APIs, EventBridge relies
// on IAM roles that you specify in the RoleARN argument in PutTargets. For
// more information, see Authentication and Access Control (path_to_url
// in the Amazon EventBridge User Guide.
//
// If another Amazon Web Services account is in the same region and has granted
// you permission (using PutPermission), you can send events to that account.
// Set that account's event bus as a target of the rules in your account. To
// send the matched events to the other account, specify that account's event
// bus as the Arn value when you run PutTargets. If your account sends events
// to another account, your account is charged for each sent event. Each event
// sent to another account is charged as a custom event. The account receiving
// the event is not charged. For more information, see Amazon EventBridge Pricing
// (path_to_url
//
// Input, InputPath, and InputTransformer are not available with PutTarget if
// the target is an event bus of a different Amazon Web Services account.
//
// If you are setting the event bus of another account as the target, and that
// account granted permission to your account through an organization instead
// of directly by the account ID, then you must specify a RoleArn with proper
// permissions in the Target structure. For more information, see Sending and
// Receiving Events Between Amazon Web Services Accounts (path_to_url
// in the Amazon EventBridge User Guide.
//
// For more information about enabling cross-account events, see PutPermission
// (path_to_url
//
// Input, InputPath, and InputTransformer are mutually exclusive and optional
// parameters of a target. When a rule is triggered due to a matched event:
//
// - If none of the following arguments are specified for a target, then
// the entire event is passed to the target in JSON format (unless the target
// is Amazon EC2 Run Command or Amazon ECS task, in which case nothing from
// the event is passed to the target).
//
// - If Input is specified in the form of valid JSON, then the matched event
// is overridden with this constant.
//
// - If InputPath is specified in the form of JSONPath (for example, $.detail),
// then only the part of the event specified in the path is passed to the
// target (for example, only the detail part of the event is passed).
//
// - If InputTransformer is specified, then one or more specified JSONPaths
// are extracted from the event and used as values in a template that you
// specify as the input to the target.
//
// When you specify InputPath or InputTransformer, you must use JSON dot notation,
// not bracket notation.
//
// When you add targets to a rule and the associated rule triggers soon after,
// new or updated targets might not be immediately invoked. Allow a short period
// of time for changes to take effect.
//
// This action can partially fail if too many requests are made at the same
// time. If that happens, FailedEntryCount is non-zero in the response and each
// entry in FailedEntries provides the ID of the failed target and the error
// code.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation PutTargets for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - LimitExceededException
// The request failed because it attempted to create resource beyond the allowed
// service quota.
//
// - ManagedRuleException
// This rule was created by an Amazon Web Services service on behalf of your
// account. It is managed by that service. If you see this error in response
// to DeleteRule or RemoveTargets, you can use the Force parameter in those
// calls to delete the rule or remove targets from the rule. You cannot modify
// these managed rules by using DisableRule, EnableRule, PutTargets, PutRule,
// TagResource, or UntagResource.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) PutTargets(input *PutTargetsInput) (*PutTargetsOutput, error) {
req, out := c.PutTargetsRequest(input)
return out, req.Send()
}
// PutTargetsWithContext is the same as PutTargets with the addition of
// the ability to pass a context and additional request options.
//
// See PutTargets for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) PutTargetsWithContext(ctx aws.Context, input *PutTargetsInput, opts ...request.Option) (*PutTargetsOutput, error) {
req, out := c.PutTargetsRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opRemovePermission = "RemovePermission"
// RemovePermissionRequest generates a "aws/request.Request" representing the
// client's request for the RemovePermission operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See RemovePermission for more information on using the RemovePermission
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the RemovePermissionRequest method.
// req, resp := client.RemovePermissionRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) RemovePermissionRequest(input *RemovePermissionInput) (req *request.Request, output *RemovePermissionOutput) {
op := &request.Operation{
Name: opRemovePermission,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &RemovePermissionInput{}
}
output = &RemovePermissionOutput{}
req = c.newRequest(op, input, output)
req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
return
}
// RemovePermission API operation for Amazon CloudWatch Events.
//
// Revokes the permission of another Amazon Web Services account to be able
// to put events to the specified event bus. Specify the account to revoke by
// the StatementId value that you associated with the account when you granted
// it permission with PutPermission. You can find the StatementId by using DescribeEventBus
// (path_to_url
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation RemovePermission for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - OperationDisabledException
// The operation you are attempting is not available in this region.
//
// See also, path_to_url
func (c *CloudWatchEvents) RemovePermission(input *RemovePermissionInput) (*RemovePermissionOutput, error) {
req, out := c.RemovePermissionRequest(input)
return out, req.Send()
}
// RemovePermissionWithContext is the same as RemovePermission with the addition of
// the ability to pass a context and additional request options.
//
// See RemovePermission for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) RemovePermissionWithContext(ctx aws.Context, input *RemovePermissionInput, opts ...request.Option) (*RemovePermissionOutput, error) {
req, out := c.RemovePermissionRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opRemoveTargets = "RemoveTargets"
// RemoveTargetsRequest generates a "aws/request.Request" representing the
// client's request for the RemoveTargets operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See RemoveTargets for more information on using the RemoveTargets
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the RemoveTargetsRequest method.
// req, resp := client.RemoveTargetsRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) RemoveTargetsRequest(input *RemoveTargetsInput) (req *request.Request, output *RemoveTargetsOutput) {
op := &request.Operation{
Name: opRemoveTargets,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &RemoveTargetsInput{}
}
output = &RemoveTargetsOutput{}
req = c.newRequest(op, input, output)
return
}
// RemoveTargets API operation for Amazon CloudWatch Events.
//
// Removes the specified targets from the specified rule. When the rule is triggered,
// those targets are no longer be invoked.
//
// When you remove a target, when the associated rule triggers, removed targets
// might continue to be invoked. Allow a short period of time for changes to
// take effect.
//
// This action can partially fail if too many requests are made at the same
// time. If that happens, FailedEntryCount is non-zero in the response and each
// entry in FailedEntries provides the ID of the failed target and the error
// code.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation RemoveTargets for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - ManagedRuleException
// This rule was created by an Amazon Web Services service on behalf of your
// account. It is managed by that service. If you see this error in response
// to DeleteRule or RemoveTargets, you can use the Force parameter in those
// calls to delete the rule or remove targets from the rule. You cannot modify
// these managed rules by using DisableRule, EnableRule, PutTargets, PutRule,
// TagResource, or UntagResource.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) RemoveTargets(input *RemoveTargetsInput) (*RemoveTargetsOutput, error) {
req, out := c.RemoveTargetsRequest(input)
return out, req.Send()
}
// RemoveTargetsWithContext is the same as RemoveTargets with the addition of
// the ability to pass a context and additional request options.
//
// See RemoveTargets for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) RemoveTargetsWithContext(ctx aws.Context, input *RemoveTargetsInput, opts ...request.Option) (*RemoveTargetsOutput, error) {
req, out := c.RemoveTargetsRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opStartReplay = "StartReplay"
// StartReplayRequest generates a "aws/request.Request" representing the
// client's request for the StartReplay operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See StartReplay for more information on using the StartReplay
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the StartReplayRequest method.
// req, resp := client.StartReplayRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) StartReplayRequest(input *StartReplayInput) (req *request.Request, output *StartReplayOutput) {
op := &request.Operation{
Name: opStartReplay,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &StartReplayInput{}
}
output = &StartReplayOutput{}
req = c.newRequest(op, input, output)
return
}
// StartReplay API operation for Amazon CloudWatch Events.
//
// Starts the specified replay. Events are not necessarily replayed in the exact
// same order that they were added to the archive. A replay processes events
// to replay based on the time in the event, and replays them using 1 minute
// intervals. If you specify an EventStartTime and an EventEndTime that covers
// a 20 minute time range, the events are replayed from the first minute of
// that 20 minute range first. Then the events from the second minute are replayed.
// You can use DescribeReplay to determine the progress of a replay. The value
// returned for EventLastReplayedTime indicates the time within the specified
// time range associated with the last event replayed.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation StartReplay for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - ResourceAlreadyExistsException
// The resource you are trying to create already exists.
//
// - InvalidEventPatternException
// The event pattern is not valid.
//
// - LimitExceededException
// The request failed because it attempted to create resource beyond the allowed
// service quota.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) StartReplay(input *StartReplayInput) (*StartReplayOutput, error) {
req, out := c.StartReplayRequest(input)
return out, req.Send()
}
// StartReplayWithContext is the same as StartReplay with the addition of
// the ability to pass a context and additional request options.
//
// See StartReplay for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) StartReplayWithContext(ctx aws.Context, input *StartReplayInput, opts ...request.Option) (*StartReplayOutput, error) {
req, out := c.StartReplayRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opTagResource = "TagResource"
// TagResourceRequest generates a "aws/request.Request" representing the
// client's request for the TagResource operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See TagResource for more information on using the TagResource
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the TagResourceRequest method.
// req, resp := client.TagResourceRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) TagResourceRequest(input *TagResourceInput) (req *request.Request, output *TagResourceOutput) {
op := &request.Operation{
Name: opTagResource,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &TagResourceInput{}
}
output = &TagResourceOutput{}
req = c.newRequest(op, input, output)
req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
return
}
// TagResource API operation for Amazon CloudWatch Events.
//
// Assigns one or more tags (key-value pairs) to the specified EventBridge resource.
// Tags can help you organize and categorize your resources. You can also use
// them to scope user permissions by granting a user permission to access or
// change only resources with certain tag values. In EventBridge, rules and
// event buses can be tagged.
//
// Tags don't have any semantic meaning to Amazon Web Services and are interpreted
// strictly as strings of characters.
//
// You can use the TagResource action with a resource that already has tags.
// If you specify a new tag key, this tag is appended to the list of tags associated
// with the resource. If you specify a tag key that is already associated with
// the resource, the new tag value that you specify replaces the previous value
// for that tag.
//
// You can associate as many as 50 tags with a resource.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation TagResource for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - ManagedRuleException
// This rule was created by an Amazon Web Services service on behalf of your
// account. It is managed by that service. If you see this error in response
// to DeleteRule or RemoveTargets, you can use the Force parameter in those
// calls to delete the rule or remove targets from the rule. You cannot modify
// these managed rules by using DisableRule, EnableRule, PutTargets, PutRule,
// TagResource, or UntagResource.
//
// See also, path_to_url
func (c *CloudWatchEvents) TagResource(input *TagResourceInput) (*TagResourceOutput, error) {
req, out := c.TagResourceRequest(input)
return out, req.Send()
}
// TagResourceWithContext is the same as TagResource with the addition of
// the ability to pass a context and additional request options.
//
// See TagResource for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) TagResourceWithContext(ctx aws.Context, input *TagResourceInput, opts ...request.Option) (*TagResourceOutput, error) {
req, out := c.TagResourceRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opTestEventPattern = "TestEventPattern"
// TestEventPatternRequest generates a "aws/request.Request" representing the
// client's request for the TestEventPattern operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See TestEventPattern for more information on using the TestEventPattern
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the TestEventPatternRequest method.
// req, resp := client.TestEventPatternRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) TestEventPatternRequest(input *TestEventPatternInput) (req *request.Request, output *TestEventPatternOutput) {
op := &request.Operation{
Name: opTestEventPattern,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &TestEventPatternInput{}
}
output = &TestEventPatternOutput{}
req = c.newRequest(op, input, output)
return
}
// TestEventPattern API operation for Amazon CloudWatch Events.
//
// Tests whether the specified event pattern matches the provided event.
//
// Most services in Amazon Web Services treat : or / as the same character in
// Amazon Resource Names (ARNs). However, EventBridge uses an exact match in
// event patterns and rules. Be sure to use the correct ARN characters when
// creating event patterns so that they match the ARN syntax in the event you
// want to match.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation TestEventPattern for usage and error information.
//
// Returned Error Types:
//
// - InvalidEventPatternException
// The event pattern is not valid.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// See also, path_to_url
func (c *CloudWatchEvents) TestEventPattern(input *TestEventPatternInput) (*TestEventPatternOutput, error) {
req, out := c.TestEventPatternRequest(input)
return out, req.Send()
}
// TestEventPatternWithContext is the same as TestEventPattern with the addition of
// the ability to pass a context and additional request options.
//
// See TestEventPattern for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) TestEventPatternWithContext(ctx aws.Context, input *TestEventPatternInput, opts ...request.Option) (*TestEventPatternOutput, error) {
req, out := c.TestEventPatternRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opUntagResource = "UntagResource"
// UntagResourceRequest generates a "aws/request.Request" representing the
// client's request for the UntagResource operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UntagResource for more information on using the UntagResource
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the UntagResourceRequest method.
// req, resp := client.UntagResourceRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) UntagResourceRequest(input *UntagResourceInput) (req *request.Request, output *UntagResourceOutput) {
op := &request.Operation{
Name: opUntagResource,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &UntagResourceInput{}
}
output = &UntagResourceOutput{}
req = c.newRequest(op, input, output)
req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
return
}
// UntagResource API operation for Amazon CloudWatch Events.
//
// Removes one or more tags from the specified EventBridge resource. In Amazon
// EventBridge (CloudWatch Events), rules and event buses can be tagged.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation UntagResource for usage and error information.
//
// Returned Error Types:
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - ManagedRuleException
// This rule was created by an Amazon Web Services service on behalf of your
// account. It is managed by that service. If you see this error in response
// to DeleteRule or RemoveTargets, you can use the Force parameter in those
// calls to delete the rule or remove targets from the rule. You cannot modify
// these managed rules by using DisableRule, EnableRule, PutTargets, PutRule,
// TagResource, or UntagResource.
//
// See also, path_to_url
func (c *CloudWatchEvents) UntagResource(input *UntagResourceInput) (*UntagResourceOutput, error) {
req, out := c.UntagResourceRequest(input)
return out, req.Send()
}
// UntagResourceWithContext is the same as UntagResource with the addition of
// the ability to pass a context and additional request options.
//
// See UntagResource for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) UntagResourceWithContext(ctx aws.Context, input *UntagResourceInput, opts ...request.Option) (*UntagResourceOutput, error) {
req, out := c.UntagResourceRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opUpdateApiDestination = "UpdateApiDestination"
// UpdateApiDestinationRequest generates a "aws/request.Request" representing the
// client's request for the UpdateApiDestination operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateApiDestination for more information on using the UpdateApiDestination
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the UpdateApiDestinationRequest method.
// req, resp := client.UpdateApiDestinationRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) UpdateApiDestinationRequest(input *UpdateApiDestinationInput) (req *request.Request, output *UpdateApiDestinationOutput) {
op := &request.Operation{
Name: opUpdateApiDestination,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &UpdateApiDestinationInput{}
}
output = &UpdateApiDestinationOutput{}
req = c.newRequest(op, input, output)
return
}
// UpdateApiDestination API operation for Amazon CloudWatch Events.
//
// Updates an API destination.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation UpdateApiDestination for usage and error information.
//
// Returned Error Types:
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - LimitExceededException
// The request failed because it attempted to create resource beyond the allowed
// service quota.
//
// See also, path_to_url
func (c *CloudWatchEvents) UpdateApiDestination(input *UpdateApiDestinationInput) (*UpdateApiDestinationOutput, error) {
req, out := c.UpdateApiDestinationRequest(input)
return out, req.Send()
}
// UpdateApiDestinationWithContext is the same as UpdateApiDestination with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateApiDestination for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) UpdateApiDestinationWithContext(ctx aws.Context, input *UpdateApiDestinationInput, opts ...request.Option) (*UpdateApiDestinationOutput, error) {
req, out := c.UpdateApiDestinationRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opUpdateArchive = "UpdateArchive"
// UpdateArchiveRequest generates a "aws/request.Request" representing the
// client's request for the UpdateArchive operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateArchive for more information on using the UpdateArchive
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the UpdateArchiveRequest method.
// req, resp := client.UpdateArchiveRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) UpdateArchiveRequest(input *UpdateArchiveInput) (req *request.Request, output *UpdateArchiveOutput) {
op := &request.Operation{
Name: opUpdateArchive,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &UpdateArchiveInput{}
}
output = &UpdateArchiveOutput{}
req = c.newRequest(op, input, output)
return
}
// UpdateArchive API operation for Amazon CloudWatch Events.
//
// Updates the specified archive.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation UpdateArchive for usage and error information.
//
// Returned Error Types:
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - LimitExceededException
// The request failed because it attempted to create resource beyond the allowed
// service quota.
//
// - InvalidEventPatternException
// The event pattern is not valid.
//
// See also, path_to_url
func (c *CloudWatchEvents) UpdateArchive(input *UpdateArchiveInput) (*UpdateArchiveOutput, error) {
req, out := c.UpdateArchiveRequest(input)
return out, req.Send()
}
// UpdateArchiveWithContext is the same as UpdateArchive with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateArchive for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) UpdateArchiveWithContext(ctx aws.Context, input *UpdateArchiveInput, opts ...request.Option) (*UpdateArchiveOutput, error) {
req, out := c.UpdateArchiveRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opUpdateConnection = "UpdateConnection"
// UpdateConnectionRequest generates a "aws/request.Request" representing the
// client's request for the UpdateConnection operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateConnection for more information on using the UpdateConnection
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
// // Example sending a request using the UpdateConnectionRequest method.
// req, resp := client.UpdateConnectionRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *CloudWatchEvents) UpdateConnectionRequest(input *UpdateConnectionInput) (req *request.Request, output *UpdateConnectionOutput) {
op := &request.Operation{
Name: opUpdateConnection,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &UpdateConnectionInput{}
}
output = &UpdateConnectionOutput{}
req = c.newRequest(op, input, output)
return
}
// UpdateConnection API operation for Amazon CloudWatch Events.
//
// Updates settings for a connection.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon CloudWatch Events's
// API operation UpdateConnection for usage and error information.
//
// Returned Error Types:
//
// - ConcurrentModificationException
// There is concurrent modification on a rule, target, archive, or replay.
//
// - ResourceNotFoundException
// An entity that you specified does not exist.
//
// - InternalException
// This exception occurs due to unexpected causes.
//
// - LimitExceededException
// The request failed because it attempted to create resource beyond the allowed
// service quota.
//
// See also, path_to_url
func (c *CloudWatchEvents) UpdateConnection(input *UpdateConnectionInput) (*UpdateConnectionOutput, error) {
req, out := c.UpdateConnectionRequest(input)
return out, req.Send()
}
// UpdateConnectionWithContext is the same as UpdateConnection with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateConnection for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *CloudWatchEvents) UpdateConnectionWithContext(ctx aws.Context, input *UpdateConnectionInput, opts ...request.Option) (*UpdateConnectionOutput, error) {
req, out := c.UpdateConnectionRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
type ActivateEventSourceInput struct {
_ struct{} `type:"structure"`
// The name of the partner event source to activate.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ActivateEventSourceInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ActivateEventSourceInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *ActivateEventSourceInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "ActivateEventSourceInput"}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetName sets the Name field's value.
func (s *ActivateEventSourceInput) SetName(v string) *ActivateEventSourceInput {
s.Name = &v
return s
}
type ActivateEventSourceOutput struct {
_ struct{} `type:"structure"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ActivateEventSourceOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ActivateEventSourceOutput) GoString() string {
return s.String()
}
// Contains details about an API destination.
type ApiDestination struct {
_ struct{} `type:"structure"`
// The ARN of the API destination.
ApiDestinationArn *string `min:"1" type:"string"`
// The state of the API destination.
ApiDestinationState *string `type:"string" enum:"ApiDestinationState"`
// The ARN of the connection specified for the API destination.
ConnectionArn *string `min:"1" type:"string"`
// A time stamp for the time that the API destination was created.
CreationTime *time.Time `type:"timestamp"`
// The method to use to connect to the HTTP endpoint.
HttpMethod *string `type:"string" enum:"ApiDestinationHttpMethod"`
// The URL to the endpoint for the API destination.
InvocationEndpoint *string `min:"1" type:"string"`
// The maximum number of invocations per second to send to the HTTP endpoint.
InvocationRateLimitPerSecond *int64 `min:"1" type:"integer"`
// A time stamp for the time that the API destination was last modified.
LastModifiedTime *time.Time `type:"timestamp"`
// The name of the API destination.
Name *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ApiDestination) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ApiDestination) GoString() string {
return s.String()
}
// SetApiDestinationArn sets the ApiDestinationArn field's value.
func (s *ApiDestination) SetApiDestinationArn(v string) *ApiDestination {
s.ApiDestinationArn = &v
return s
}
// SetApiDestinationState sets the ApiDestinationState field's value.
func (s *ApiDestination) SetApiDestinationState(v string) *ApiDestination {
s.ApiDestinationState = &v
return s
}
// SetConnectionArn sets the ConnectionArn field's value.
func (s *ApiDestination) SetConnectionArn(v string) *ApiDestination {
s.ConnectionArn = &v
return s
}
// SetCreationTime sets the CreationTime field's value.
func (s *ApiDestination) SetCreationTime(v time.Time) *ApiDestination {
s.CreationTime = &v
return s
}
// SetHttpMethod sets the HttpMethod field's value.
func (s *ApiDestination) SetHttpMethod(v string) *ApiDestination {
s.HttpMethod = &v
return s
}
// SetInvocationEndpoint sets the InvocationEndpoint field's value.
func (s *ApiDestination) SetInvocationEndpoint(v string) *ApiDestination {
s.InvocationEndpoint = &v
return s
}
// SetInvocationRateLimitPerSecond sets the InvocationRateLimitPerSecond field's value.
func (s *ApiDestination) SetInvocationRateLimitPerSecond(v int64) *ApiDestination {
s.InvocationRateLimitPerSecond = &v
return s
}
// SetLastModifiedTime sets the LastModifiedTime field's value.
func (s *ApiDestination) SetLastModifiedTime(v time.Time) *ApiDestination {
s.LastModifiedTime = &v
return s
}
// SetName sets the Name field's value.
func (s *ApiDestination) SetName(v string) *ApiDestination {
s.Name = &v
return s
}
// An Archive object that contains details about an archive.
type Archive struct {
_ struct{} `type:"structure"`
// The name of the archive.
ArchiveName *string `min:"1" type:"string"`
// The time stamp for the time that the archive was created.
CreationTime *time.Time `type:"timestamp"`
// The number of events in the archive.
EventCount *int64 `type:"long"`
// The ARN of the event bus associated with the archive. Only events from this
// event bus are sent to the archive.
EventSourceArn *string `min:"1" type:"string"`
// The number of days to retain events in the archive before they are deleted.
RetentionDays *int64 `type:"integer"`
// The size of the archive, in bytes.
SizeBytes *int64 `type:"long"`
// The current state of the archive.
State *string `type:"string" enum:"ArchiveState"`
// A description for the reason that the archive is in the current state.
StateReason *string `type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s Archive) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s Archive) GoString() string {
return s.String()
}
// SetArchiveName sets the ArchiveName field's value.
func (s *Archive) SetArchiveName(v string) *Archive {
s.ArchiveName = &v
return s
}
// SetCreationTime sets the CreationTime field's value.
func (s *Archive) SetCreationTime(v time.Time) *Archive {
s.CreationTime = &v
return s
}
// SetEventCount sets the EventCount field's value.
func (s *Archive) SetEventCount(v int64) *Archive {
s.EventCount = &v
return s
}
// SetEventSourceArn sets the EventSourceArn field's value.
func (s *Archive) SetEventSourceArn(v string) *Archive {
s.EventSourceArn = &v
return s
}
// SetRetentionDays sets the RetentionDays field's value.
func (s *Archive) SetRetentionDays(v int64) *Archive {
s.RetentionDays = &v
return s
}
// SetSizeBytes sets the SizeBytes field's value.
func (s *Archive) SetSizeBytes(v int64) *Archive {
s.SizeBytes = &v
return s
}
// SetState sets the State field's value.
func (s *Archive) SetState(v string) *Archive {
s.State = &v
return s
}
// SetStateReason sets the StateReason field's value.
func (s *Archive) SetStateReason(v string) *Archive {
s.StateReason = &v
return s
}
// This structure specifies the VPC subnets and security groups for the task,
// and whether a public IP address is to be used. This structure is relevant
// only for ECS tasks that use the awsvpc network mode.
type AwsVpcConfiguration struct {
_ struct{} `type:"structure"`
// Specifies whether the task's elastic network interface receives a public
// IP address. You can specify ENABLED only when LaunchType in EcsParameters
// is set to FARGATE.
AssignPublicIp *string `type:"string" enum:"AssignPublicIp"`
// Specifies the security groups associated with the task. These security groups
// must all be in the same VPC. You can specify as many as five security groups.
// If you do not specify a security group, the default security group for the
// VPC is used.
SecurityGroups []*string `type:"list"`
// Specifies the subnets associated with the task. These subnets must all be
// in the same VPC. You can specify as many as 16 subnets.
//
// Subnets is a required field
Subnets []*string `type:"list" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s AwsVpcConfiguration) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s AwsVpcConfiguration) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *AwsVpcConfiguration) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "AwsVpcConfiguration"}
if s.Subnets == nil {
invalidParams.Add(request.NewErrParamRequired("Subnets"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetAssignPublicIp sets the AssignPublicIp field's value.
func (s *AwsVpcConfiguration) SetAssignPublicIp(v string) *AwsVpcConfiguration {
s.AssignPublicIp = &v
return s
}
// SetSecurityGroups sets the SecurityGroups field's value.
func (s *AwsVpcConfiguration) SetSecurityGroups(v []*string) *AwsVpcConfiguration {
s.SecurityGroups = v
return s
}
// SetSubnets sets the Subnets field's value.
func (s *AwsVpcConfiguration) SetSubnets(v []*string) *AwsVpcConfiguration {
s.Subnets = v
return s
}
// The array properties for the submitted job, such as the size of the array.
// The array size can be between 2 and 10,000. If you specify array properties
// for a job, it becomes an array job. This parameter is used only if the target
// is an Batch job.
type BatchArrayProperties struct {
_ struct{} `type:"structure"`
// The size of the array, if this is an array batch job. Valid values are integers
// between 2 and 10,000.
Size *int64 `type:"integer"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s BatchArrayProperties) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s BatchArrayProperties) GoString() string {
return s.String()
}
// SetSize sets the Size field's value.
func (s *BatchArrayProperties) SetSize(v int64) *BatchArrayProperties {
s.Size = &v
return s
}
// The custom parameters to be used when the target is an Batch job.
type BatchParameters struct {
_ struct{} `type:"structure"`
// The array properties for the submitted job, such as the size of the array.
// The array size can be between 2 and 10,000. If you specify array properties
// for a job, it becomes an array job. This parameter is used only if the target
// is an Batch job.
ArrayProperties *BatchArrayProperties `type:"structure"`
// The ARN or name of the job definition to use if the event target is an Batch
// job. This job definition must already exist.
//
// JobDefinition is a required field
JobDefinition *string `type:"string" required:"true"`
// The name to use for this execution of the job, if the target is an Batch
// job.
//
// JobName is a required field
JobName *string `type:"string" required:"true"`
// The retry strategy to use for failed jobs, if the target is an Batch job.
// The retry strategy is the number of times to retry the failed job execution.
// Valid values are 110. When you specify a retry strategy here, it overrides
// the retry strategy defined in the job definition.
RetryStrategy *BatchRetryStrategy `type:"structure"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s BatchParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s BatchParameters) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *BatchParameters) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "BatchParameters"}
if s.JobDefinition == nil {
invalidParams.Add(request.NewErrParamRequired("JobDefinition"))
}
if s.JobName == nil {
invalidParams.Add(request.NewErrParamRequired("JobName"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetArrayProperties sets the ArrayProperties field's value.
func (s *BatchParameters) SetArrayProperties(v *BatchArrayProperties) *BatchParameters {
s.ArrayProperties = v
return s
}
// SetJobDefinition sets the JobDefinition field's value.
func (s *BatchParameters) SetJobDefinition(v string) *BatchParameters {
s.JobDefinition = &v
return s
}
// SetJobName sets the JobName field's value.
func (s *BatchParameters) SetJobName(v string) *BatchParameters {
s.JobName = &v
return s
}
// SetRetryStrategy sets the RetryStrategy field's value.
func (s *BatchParameters) SetRetryStrategy(v *BatchRetryStrategy) *BatchParameters {
s.RetryStrategy = v
return s
}
// The retry strategy to use for failed jobs, if the target is an Batch job.
// If you specify a retry strategy here, it overrides the retry strategy defined
// in the job definition.
type BatchRetryStrategy struct {
_ struct{} `type:"structure"`
// The number of times to attempt to retry, if the job fails. Valid values are
// 110.
Attempts *int64 `type:"integer"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s BatchRetryStrategy) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s BatchRetryStrategy) GoString() string {
return s.String()
}
// SetAttempts sets the Attempts field's value.
func (s *BatchRetryStrategy) SetAttempts(v int64) *BatchRetryStrategy {
s.Attempts = &v
return s
}
type CancelReplayInput struct {
_ struct{} `type:"structure"`
// The name of the replay to cancel.
//
// ReplayName is a required field
ReplayName *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CancelReplayInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CancelReplayInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *CancelReplayInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "CancelReplayInput"}
if s.ReplayName == nil {
invalidParams.Add(request.NewErrParamRequired("ReplayName"))
}
if s.ReplayName != nil && len(*s.ReplayName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ReplayName", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetReplayName sets the ReplayName field's value.
func (s *CancelReplayInput) SetReplayName(v string) *CancelReplayInput {
s.ReplayName = &v
return s
}
type CancelReplayOutput struct {
_ struct{} `type:"structure"`
// The ARN of the replay to cancel.
ReplayArn *string `min:"1" type:"string"`
// The current state of the replay.
State *string `type:"string" enum:"ReplayState"`
// The reason that the replay is in the current state.
StateReason *string `type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CancelReplayOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CancelReplayOutput) GoString() string {
return s.String()
}
// SetReplayArn sets the ReplayArn field's value.
func (s *CancelReplayOutput) SetReplayArn(v string) *CancelReplayOutput {
s.ReplayArn = &v
return s
}
// SetState sets the State field's value.
func (s *CancelReplayOutput) SetState(v string) *CancelReplayOutput {
s.State = &v
return s
}
// SetStateReason sets the StateReason field's value.
func (s *CancelReplayOutput) SetStateReason(v string) *CancelReplayOutput {
s.StateReason = &v
return s
}
// The details of a capacity provider strategy. To learn more, see CapacityProviderStrategyItem
// (path_to_url
// in the Amazon ECS API Reference.
type CapacityProviderStrategyItem struct {
_ struct{} `type:"structure"`
// The base value designates how many tasks, at a minimum, to run on the specified
// capacity provider. Only one capacity provider in a capacity provider strategy
// can have a base defined. If no value is specified, the default value of 0
// is used.
Base *int64 `locationName:"base" type:"integer"`
// The short name of the capacity provider.
//
// CapacityProvider is a required field
CapacityProvider *string `locationName:"capacityProvider" min:"1" type:"string" required:"true"`
// The weight value designates the relative percentage of the total number of
// tasks launched that should use the specified capacity provider. The weight
// value is taken into consideration after the base value, if defined, is satisfied.
Weight *int64 `locationName:"weight" type:"integer"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CapacityProviderStrategyItem) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CapacityProviderStrategyItem) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *CapacityProviderStrategyItem) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "CapacityProviderStrategyItem"}
if s.CapacityProvider == nil {
invalidParams.Add(request.NewErrParamRequired("CapacityProvider"))
}
if s.CapacityProvider != nil && len(*s.CapacityProvider) < 1 {
invalidParams.Add(request.NewErrParamMinLen("CapacityProvider", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetBase sets the Base field's value.
func (s *CapacityProviderStrategyItem) SetBase(v int64) *CapacityProviderStrategyItem {
s.Base = &v
return s
}
// SetCapacityProvider sets the CapacityProvider field's value.
func (s *CapacityProviderStrategyItem) SetCapacityProvider(v string) *CapacityProviderStrategyItem {
s.CapacityProvider = &v
return s
}
// SetWeight sets the Weight field's value.
func (s *CapacityProviderStrategyItem) SetWeight(v int64) *CapacityProviderStrategyItem {
s.Weight = &v
return s
}
// There is concurrent modification on a rule, target, archive, or replay.
type ConcurrentModificationException struct {
_ struct{} `type:"structure"`
RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`
Message_ *string `locationName:"message" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ConcurrentModificationException) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ConcurrentModificationException) GoString() string {
return s.String()
}
func newErrorConcurrentModificationException(v protocol.ResponseMetadata) error {
return &ConcurrentModificationException{
RespMetadata: v,
}
}
// Code returns the exception type name.
func (s *ConcurrentModificationException) Code() string {
return "ConcurrentModificationException"
}
// Message returns the exception's message.
func (s *ConcurrentModificationException) Message() string {
if s.Message_ != nil {
return *s.Message_
}
return ""
}
// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *ConcurrentModificationException) OrigErr() error {
return nil
}
func (s *ConcurrentModificationException) Error() string {
return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}
// Status code returns the HTTP status code for the request's response error.
func (s *ConcurrentModificationException) StatusCode() int {
return s.RespMetadata.StatusCode
}
// RequestID returns the service's response RequestID for request.
func (s *ConcurrentModificationException) RequestID() string {
return s.RespMetadata.RequestID
}
// A JSON string which you can use to limit the event bus permissions you are
// granting to only accounts that fulfill the condition. Currently, the only
// supported condition is membership in a certain Amazon Web Services organization.
// The string must contain Type, Key, and Value fields. The Value field specifies
// the ID of the Amazon Web Services organization. Following is an example value
// for Condition:
//
// '{"Type" : "StringEquals", "Key": "aws:PrincipalOrgID", "Value": "o-1234567890"}'
type Condition struct {
_ struct{} `type:"structure"`
// Specifies the key for the condition. Currently the only supported key is
// aws:PrincipalOrgID.
//
// Key is a required field
Key *string `type:"string" required:"true"`
// Specifies the type of condition. Currently the only supported value is StringEquals.
//
// Type is a required field
Type *string `type:"string" required:"true"`
// Specifies the value for the key. Currently, this must be the ID of the organization.
//
// Value is a required field
Value *string `type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s Condition) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s Condition) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *Condition) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "Condition"}
if s.Key == nil {
invalidParams.Add(request.NewErrParamRequired("Key"))
}
if s.Type == nil {
invalidParams.Add(request.NewErrParamRequired("Type"))
}
if s.Value == nil {
invalidParams.Add(request.NewErrParamRequired("Value"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetKey sets the Key field's value.
func (s *Condition) SetKey(v string) *Condition {
s.Key = &v
return s
}
// SetType sets the Type field's value.
func (s *Condition) SetType(v string) *Condition {
s.Type = &v
return s
}
// SetValue sets the Value field's value.
func (s *Condition) SetValue(v string) *Condition {
s.Value = &v
return s
}
// Contains information about a connection.
type Connection struct {
_ struct{} `type:"structure"`
// The authorization type specified for the connection.
AuthorizationType *string `type:"string" enum:"ConnectionAuthorizationType"`
// The ARN of the connection.
ConnectionArn *string `min:"1" type:"string"`
// The state of the connection.
ConnectionState *string `type:"string" enum:"ConnectionState"`
// A time stamp for the time that the connection was created.
CreationTime *time.Time `type:"timestamp"`
// A time stamp for the time that the connection was last authorized.
LastAuthorizedTime *time.Time `type:"timestamp"`
// A time stamp for the time that the connection was last modified.
LastModifiedTime *time.Time `type:"timestamp"`
// The name of the connection.
Name *string `min:"1" type:"string"`
// The reason that the connection is in the connection state.
StateReason *string `type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s Connection) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s Connection) GoString() string {
return s.String()
}
// SetAuthorizationType sets the AuthorizationType field's value.
func (s *Connection) SetAuthorizationType(v string) *Connection {
s.AuthorizationType = &v
return s
}
// SetConnectionArn sets the ConnectionArn field's value.
func (s *Connection) SetConnectionArn(v string) *Connection {
s.ConnectionArn = &v
return s
}
// SetConnectionState sets the ConnectionState field's value.
func (s *Connection) SetConnectionState(v string) *Connection {
s.ConnectionState = &v
return s
}
// SetCreationTime sets the CreationTime field's value.
func (s *Connection) SetCreationTime(v time.Time) *Connection {
s.CreationTime = &v
return s
}
// SetLastAuthorizedTime sets the LastAuthorizedTime field's value.
func (s *Connection) SetLastAuthorizedTime(v time.Time) *Connection {
s.LastAuthorizedTime = &v
return s
}
// SetLastModifiedTime sets the LastModifiedTime field's value.
func (s *Connection) SetLastModifiedTime(v time.Time) *Connection {
s.LastModifiedTime = &v
return s
}
// SetName sets the Name field's value.
func (s *Connection) SetName(v string) *Connection {
s.Name = &v
return s
}
// SetStateReason sets the StateReason field's value.
func (s *Connection) SetStateReason(v string) *Connection {
s.StateReason = &v
return s
}
// Contains the authorization parameters for the connection if API Key is specified
// as the authorization type.
type ConnectionApiKeyAuthResponseParameters struct {
_ struct{} `type:"structure"`
// The name of the header to use for the APIKeyValue used for authorization.
ApiKeyName *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ConnectionApiKeyAuthResponseParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ConnectionApiKeyAuthResponseParameters) GoString() string {
return s.String()
}
// SetApiKeyName sets the ApiKeyName field's value.
func (s *ConnectionApiKeyAuthResponseParameters) SetApiKeyName(v string) *ConnectionApiKeyAuthResponseParameters {
s.ApiKeyName = &v
return s
}
// Contains the authorization parameters to use for the connection.
type ConnectionAuthResponseParameters struct {
_ struct{} `type:"structure"`
// The API Key parameters to use for authorization.
ApiKeyAuthParameters *ConnectionApiKeyAuthResponseParameters `type:"structure"`
// The authorization parameters for Basic authorization.
BasicAuthParameters *ConnectionBasicAuthResponseParameters `type:"structure"`
// Additional parameters for the connection that are passed through with every
// invocation to the HTTP endpoint.
InvocationHttpParameters *ConnectionHttpParameters `type:"structure"`
// The OAuth parameters to use for authorization.
OAuthParameters *ConnectionOAuthResponseParameters `type:"structure"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ConnectionAuthResponseParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ConnectionAuthResponseParameters) GoString() string {
return s.String()
}
// SetApiKeyAuthParameters sets the ApiKeyAuthParameters field's value.
func (s *ConnectionAuthResponseParameters) SetApiKeyAuthParameters(v *ConnectionApiKeyAuthResponseParameters) *ConnectionAuthResponseParameters {
s.ApiKeyAuthParameters = v
return s
}
// SetBasicAuthParameters sets the BasicAuthParameters field's value.
func (s *ConnectionAuthResponseParameters) SetBasicAuthParameters(v *ConnectionBasicAuthResponseParameters) *ConnectionAuthResponseParameters {
s.BasicAuthParameters = v
return s
}
// SetInvocationHttpParameters sets the InvocationHttpParameters field's value.
func (s *ConnectionAuthResponseParameters) SetInvocationHttpParameters(v *ConnectionHttpParameters) *ConnectionAuthResponseParameters {
s.InvocationHttpParameters = v
return s
}
// SetOAuthParameters sets the OAuthParameters field's value.
func (s *ConnectionAuthResponseParameters) SetOAuthParameters(v *ConnectionOAuthResponseParameters) *ConnectionAuthResponseParameters {
s.OAuthParameters = v
return s
}
// Contains the authorization parameters for the connection if Basic is specified
// as the authorization type.
type ConnectionBasicAuthResponseParameters struct {
_ struct{} `type:"structure"`
// The user name to use for Basic authorization.
Username *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ConnectionBasicAuthResponseParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ConnectionBasicAuthResponseParameters) GoString() string {
return s.String()
}
// SetUsername sets the Username field's value.
func (s *ConnectionBasicAuthResponseParameters) SetUsername(v string) *ConnectionBasicAuthResponseParameters {
s.Username = &v
return s
}
// Additional parameter included in the body. You can include up to 100 additional
// body parameters per request. An event payload cannot exceed 64 KB.
type ConnectionBodyParameter struct {
_ struct{} `type:"structure"`
// Specified whether the value is secret.
IsValueSecret *bool `type:"boolean"`
// The key for the parameter.
Key *string `type:"string"`
// The value associated with the key.
//
// Value is a sensitive parameter and its value will be
// replaced with "sensitive" in string returned by ConnectionBodyParameter's
// String and GoString methods.
Value *string `type:"string" sensitive:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ConnectionBodyParameter) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ConnectionBodyParameter) GoString() string {
return s.String()
}
// SetIsValueSecret sets the IsValueSecret field's value.
func (s *ConnectionBodyParameter) SetIsValueSecret(v bool) *ConnectionBodyParameter {
s.IsValueSecret = &v
return s
}
// SetKey sets the Key field's value.
func (s *ConnectionBodyParameter) SetKey(v string) *ConnectionBodyParameter {
s.Key = &v
return s
}
// SetValue sets the Value field's value.
func (s *ConnectionBodyParameter) SetValue(v string) *ConnectionBodyParameter {
s.Value = &v
return s
}
// Additional parameter included in the header. You can include up to 100 additional
// header parameters per request. An event payload cannot exceed 64 KB.
type ConnectionHeaderParameter struct {
_ struct{} `type:"structure"`
// Specified whether the value is a secret.
IsValueSecret *bool `type:"boolean"`
// The key for the parameter.
Key *string `type:"string"`
// The value associated with the key.
//
// Value is a sensitive parameter and its value will be
// replaced with "sensitive" in string returned by ConnectionHeaderParameter's
// String and GoString methods.
Value *string `type:"string" sensitive:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ConnectionHeaderParameter) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ConnectionHeaderParameter) GoString() string {
return s.String()
}
// SetIsValueSecret sets the IsValueSecret field's value.
func (s *ConnectionHeaderParameter) SetIsValueSecret(v bool) *ConnectionHeaderParameter {
s.IsValueSecret = &v
return s
}
// SetKey sets the Key field's value.
func (s *ConnectionHeaderParameter) SetKey(v string) *ConnectionHeaderParameter {
s.Key = &v
return s
}
// SetValue sets the Value field's value.
func (s *ConnectionHeaderParameter) SetValue(v string) *ConnectionHeaderParameter {
s.Value = &v
return s
}
// Contains additional parameters for the connection.
type ConnectionHttpParameters struct {
_ struct{} `type:"structure"`
// Contains additional body string parameters for the connection.
BodyParameters []*ConnectionBodyParameter `type:"list"`
// Contains additional header parameters for the connection.
HeaderParameters []*ConnectionHeaderParameter `type:"list"`
// Contains additional query string parameters for the connection.
QueryStringParameters []*ConnectionQueryStringParameter `type:"list"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ConnectionHttpParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ConnectionHttpParameters) GoString() string {
return s.String()
}
// SetBodyParameters sets the BodyParameters field's value.
func (s *ConnectionHttpParameters) SetBodyParameters(v []*ConnectionBodyParameter) *ConnectionHttpParameters {
s.BodyParameters = v
return s
}
// SetHeaderParameters sets the HeaderParameters field's value.
func (s *ConnectionHttpParameters) SetHeaderParameters(v []*ConnectionHeaderParameter) *ConnectionHttpParameters {
s.HeaderParameters = v
return s
}
// SetQueryStringParameters sets the QueryStringParameters field's value.
func (s *ConnectionHttpParameters) SetQueryStringParameters(v []*ConnectionQueryStringParameter) *ConnectionHttpParameters {
s.QueryStringParameters = v
return s
}
// Contains the client response parameters for the connection when OAuth is
// specified as the authorization type.
type ConnectionOAuthClientResponseParameters struct {
_ struct{} `type:"structure"`
// The client ID associated with the response to the connection request.
ClientID *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ConnectionOAuthClientResponseParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ConnectionOAuthClientResponseParameters) GoString() string {
return s.String()
}
// SetClientID sets the ClientID field's value.
func (s *ConnectionOAuthClientResponseParameters) SetClientID(v string) *ConnectionOAuthClientResponseParameters {
s.ClientID = &v
return s
}
// Contains the response parameters when OAuth is specified as the authorization
// type.
type ConnectionOAuthResponseParameters struct {
_ struct{} `type:"structure"`
// The URL to the HTTP endpoint that authorized the request.
AuthorizationEndpoint *string `min:"1" type:"string"`
// A ConnectionOAuthClientResponseParameters object that contains details about
// the client parameters returned when OAuth is specified as the authorization
// type.
ClientParameters *ConnectionOAuthClientResponseParameters `type:"structure"`
// The method used to connect to the HTTP endpoint.
HttpMethod *string `type:"string" enum:"ConnectionOAuthHttpMethod"`
// The additional HTTP parameters used for the OAuth authorization request.
OAuthHttpParameters *ConnectionHttpParameters `type:"structure"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ConnectionOAuthResponseParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ConnectionOAuthResponseParameters) GoString() string {
return s.String()
}
// SetAuthorizationEndpoint sets the AuthorizationEndpoint field's value.
func (s *ConnectionOAuthResponseParameters) SetAuthorizationEndpoint(v string) *ConnectionOAuthResponseParameters {
s.AuthorizationEndpoint = &v
return s
}
// SetClientParameters sets the ClientParameters field's value.
func (s *ConnectionOAuthResponseParameters) SetClientParameters(v *ConnectionOAuthClientResponseParameters) *ConnectionOAuthResponseParameters {
s.ClientParameters = v
return s
}
// SetHttpMethod sets the HttpMethod field's value.
func (s *ConnectionOAuthResponseParameters) SetHttpMethod(v string) *ConnectionOAuthResponseParameters {
s.HttpMethod = &v
return s
}
// SetOAuthHttpParameters sets the OAuthHttpParameters field's value.
func (s *ConnectionOAuthResponseParameters) SetOAuthHttpParameters(v *ConnectionHttpParameters) *ConnectionOAuthResponseParameters {
s.OAuthHttpParameters = v
return s
}
// Additional query string parameter for the connection. You can include up
// to 100 additional query string parameters per request. Each additional parameter
// counts towards the event payload size, which cannot exceed 64 KB.
type ConnectionQueryStringParameter struct {
_ struct{} `type:"structure"`
// Specifies whether the value is secret.
IsValueSecret *bool `type:"boolean"`
// The key for a query string parameter.
Key *string `type:"string"`
// The value associated with the key for the query string parameter.
//
// Value is a sensitive parameter and its value will be
// replaced with "sensitive" in string returned by ConnectionQueryStringParameter's
// String and GoString methods.
Value *string `type:"string" sensitive:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ConnectionQueryStringParameter) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ConnectionQueryStringParameter) GoString() string {
return s.String()
}
// SetIsValueSecret sets the IsValueSecret field's value.
func (s *ConnectionQueryStringParameter) SetIsValueSecret(v bool) *ConnectionQueryStringParameter {
s.IsValueSecret = &v
return s
}
// SetKey sets the Key field's value.
func (s *ConnectionQueryStringParameter) SetKey(v string) *ConnectionQueryStringParameter {
s.Key = &v
return s
}
// SetValue sets the Value field's value.
func (s *ConnectionQueryStringParameter) SetValue(v string) *ConnectionQueryStringParameter {
s.Value = &v
return s
}
type CreateApiDestinationInput struct {
_ struct{} `type:"structure"`
// The ARN of the connection to use for the API destination. The destination
// endpoint must support the authorization type specified for the connection.
//
// ConnectionArn is a required field
ConnectionArn *string `min:"1" type:"string" required:"true"`
// A description for the API destination to create.
Description *string `type:"string"`
// The method to use for the request to the HTTP invocation endpoint.
//
// HttpMethod is a required field
HttpMethod *string `type:"string" required:"true" enum:"ApiDestinationHttpMethod"`
// The URL to the HTTP invocation endpoint for the API destination.
//
// InvocationEndpoint is a required field
InvocationEndpoint *string `min:"1" type:"string" required:"true"`
// The maximum number of requests per second to send to the HTTP invocation
// endpoint.
InvocationRateLimitPerSecond *int64 `min:"1" type:"integer"`
// The name for the API destination to create.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateApiDestinationInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateApiDestinationInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateApiDestinationInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "CreateApiDestinationInput"}
if s.ConnectionArn == nil {
invalidParams.Add(request.NewErrParamRequired("ConnectionArn"))
}
if s.ConnectionArn != nil && len(*s.ConnectionArn) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ConnectionArn", 1))
}
if s.HttpMethod == nil {
invalidParams.Add(request.NewErrParamRequired("HttpMethod"))
}
if s.InvocationEndpoint == nil {
invalidParams.Add(request.NewErrParamRequired("InvocationEndpoint"))
}
if s.InvocationEndpoint != nil && len(*s.InvocationEndpoint) < 1 {
invalidParams.Add(request.NewErrParamMinLen("InvocationEndpoint", 1))
}
if s.InvocationRateLimitPerSecond != nil && *s.InvocationRateLimitPerSecond < 1 {
invalidParams.Add(request.NewErrParamMinValue("InvocationRateLimitPerSecond", 1))
}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetConnectionArn sets the ConnectionArn field's value.
func (s *CreateApiDestinationInput) SetConnectionArn(v string) *CreateApiDestinationInput {
s.ConnectionArn = &v
return s
}
// SetDescription sets the Description field's value.
func (s *CreateApiDestinationInput) SetDescription(v string) *CreateApiDestinationInput {
s.Description = &v
return s
}
// SetHttpMethod sets the HttpMethod field's value.
func (s *CreateApiDestinationInput) SetHttpMethod(v string) *CreateApiDestinationInput {
s.HttpMethod = &v
return s
}
// SetInvocationEndpoint sets the InvocationEndpoint field's value.
func (s *CreateApiDestinationInput) SetInvocationEndpoint(v string) *CreateApiDestinationInput {
s.InvocationEndpoint = &v
return s
}
// SetInvocationRateLimitPerSecond sets the InvocationRateLimitPerSecond field's value.
func (s *CreateApiDestinationInput) SetInvocationRateLimitPerSecond(v int64) *CreateApiDestinationInput {
s.InvocationRateLimitPerSecond = &v
return s
}
// SetName sets the Name field's value.
func (s *CreateApiDestinationInput) SetName(v string) *CreateApiDestinationInput {
s.Name = &v
return s
}
type CreateApiDestinationOutput struct {
_ struct{} `type:"structure"`
// The ARN of the API destination that was created by the request.
ApiDestinationArn *string `min:"1" type:"string"`
// The state of the API destination that was created by the request.
ApiDestinationState *string `type:"string" enum:"ApiDestinationState"`
// A time stamp indicating the time that the API destination was created.
CreationTime *time.Time `type:"timestamp"`
// A time stamp indicating the time that the API destination was last modified.
LastModifiedTime *time.Time `type:"timestamp"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateApiDestinationOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateApiDestinationOutput) GoString() string {
return s.String()
}
// SetApiDestinationArn sets the ApiDestinationArn field's value.
func (s *CreateApiDestinationOutput) SetApiDestinationArn(v string) *CreateApiDestinationOutput {
s.ApiDestinationArn = &v
return s
}
// SetApiDestinationState sets the ApiDestinationState field's value.
func (s *CreateApiDestinationOutput) SetApiDestinationState(v string) *CreateApiDestinationOutput {
s.ApiDestinationState = &v
return s
}
// SetCreationTime sets the CreationTime field's value.
func (s *CreateApiDestinationOutput) SetCreationTime(v time.Time) *CreateApiDestinationOutput {
s.CreationTime = &v
return s
}
// SetLastModifiedTime sets the LastModifiedTime field's value.
func (s *CreateApiDestinationOutput) SetLastModifiedTime(v time.Time) *CreateApiDestinationOutput {
s.LastModifiedTime = &v
return s
}
type CreateArchiveInput struct {
_ struct{} `type:"structure"`
// The name for the archive to create.
//
// ArchiveName is a required field
ArchiveName *string `min:"1" type:"string" required:"true"`
// A description for the archive.
Description *string `type:"string"`
// An event pattern to use to filter events sent to the archive.
EventPattern *string `type:"string"`
// The ARN of the event bus that sends events to the archive.
//
// EventSourceArn is a required field
EventSourceArn *string `min:"1" type:"string" required:"true"`
// The number of days to retain events for. Default value is 0. If set to 0,
// events are retained indefinitely
RetentionDays *int64 `type:"integer"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateArchiveInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateArchiveInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateArchiveInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "CreateArchiveInput"}
if s.ArchiveName == nil {
invalidParams.Add(request.NewErrParamRequired("ArchiveName"))
}
if s.ArchiveName != nil && len(*s.ArchiveName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ArchiveName", 1))
}
if s.EventSourceArn == nil {
invalidParams.Add(request.NewErrParamRequired("EventSourceArn"))
}
if s.EventSourceArn != nil && len(*s.EventSourceArn) < 1 {
invalidParams.Add(request.NewErrParamMinLen("EventSourceArn", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetArchiveName sets the ArchiveName field's value.
func (s *CreateArchiveInput) SetArchiveName(v string) *CreateArchiveInput {
s.ArchiveName = &v
return s
}
// SetDescription sets the Description field's value.
func (s *CreateArchiveInput) SetDescription(v string) *CreateArchiveInput {
s.Description = &v
return s
}
// SetEventPattern sets the EventPattern field's value.
func (s *CreateArchiveInput) SetEventPattern(v string) *CreateArchiveInput {
s.EventPattern = &v
return s
}
// SetEventSourceArn sets the EventSourceArn field's value.
func (s *CreateArchiveInput) SetEventSourceArn(v string) *CreateArchiveInput {
s.EventSourceArn = &v
return s
}
// SetRetentionDays sets the RetentionDays field's value.
func (s *CreateArchiveInput) SetRetentionDays(v int64) *CreateArchiveInput {
s.RetentionDays = &v
return s
}
type CreateArchiveOutput struct {
_ struct{} `type:"structure"`
// The ARN of the archive that was created.
ArchiveArn *string `min:"1" type:"string"`
// The time at which the archive was created.
CreationTime *time.Time `type:"timestamp"`
// The state of the archive that was created.
State *string `type:"string" enum:"ArchiveState"`
// The reason that the archive is in the state.
StateReason *string `type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateArchiveOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateArchiveOutput) GoString() string {
return s.String()
}
// SetArchiveArn sets the ArchiveArn field's value.
func (s *CreateArchiveOutput) SetArchiveArn(v string) *CreateArchiveOutput {
s.ArchiveArn = &v
return s
}
// SetCreationTime sets the CreationTime field's value.
func (s *CreateArchiveOutput) SetCreationTime(v time.Time) *CreateArchiveOutput {
s.CreationTime = &v
return s
}
// SetState sets the State field's value.
func (s *CreateArchiveOutput) SetState(v string) *CreateArchiveOutput {
s.State = &v
return s
}
// SetStateReason sets the StateReason field's value.
func (s *CreateArchiveOutput) SetStateReason(v string) *CreateArchiveOutput {
s.StateReason = &v
return s
}
// Contains the API key authorization parameters for the connection.
type CreateConnectionApiKeyAuthRequestParameters struct {
_ struct{} `type:"structure"`
// The name of the API key to use for authorization.
//
// ApiKeyName is a required field
ApiKeyName *string `min:"1" type:"string" required:"true"`
// The value for the API key to use for authorization.
//
// ApiKeyValue is a sensitive parameter and its value will be
// replaced with "sensitive" in string returned by CreateConnectionApiKeyAuthRequestParameters's
// String and GoString methods.
//
// ApiKeyValue is a required field
ApiKeyValue *string `min:"1" type:"string" required:"true" sensitive:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateConnectionApiKeyAuthRequestParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateConnectionApiKeyAuthRequestParameters) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateConnectionApiKeyAuthRequestParameters) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "CreateConnectionApiKeyAuthRequestParameters"}
if s.ApiKeyName == nil {
invalidParams.Add(request.NewErrParamRequired("ApiKeyName"))
}
if s.ApiKeyName != nil && len(*s.ApiKeyName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ApiKeyName", 1))
}
if s.ApiKeyValue == nil {
invalidParams.Add(request.NewErrParamRequired("ApiKeyValue"))
}
if s.ApiKeyValue != nil && len(*s.ApiKeyValue) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ApiKeyValue", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApiKeyName sets the ApiKeyName field's value.
func (s *CreateConnectionApiKeyAuthRequestParameters) SetApiKeyName(v string) *CreateConnectionApiKeyAuthRequestParameters {
s.ApiKeyName = &v
return s
}
// SetApiKeyValue sets the ApiKeyValue field's value.
func (s *CreateConnectionApiKeyAuthRequestParameters) SetApiKeyValue(v string) *CreateConnectionApiKeyAuthRequestParameters {
s.ApiKeyValue = &v
return s
}
// Contains the authorization parameters for the connection.
type CreateConnectionAuthRequestParameters struct {
_ struct{} `type:"structure"`
// A CreateConnectionApiKeyAuthRequestParameters object that contains the API
// key authorization parameters to use for the connection.
ApiKeyAuthParameters *CreateConnectionApiKeyAuthRequestParameters `type:"structure"`
// A CreateConnectionBasicAuthRequestParameters object that contains the Basic
// authorization parameters to use for the connection.
BasicAuthParameters *CreateConnectionBasicAuthRequestParameters `type:"structure"`
// A ConnectionHttpParameters object that contains the API key authorization
// parameters to use for the connection. Note that if you include additional
// parameters for the target of a rule via HttpParameters, including query strings,
// the parameters added for the connection take precedence.
InvocationHttpParameters *ConnectionHttpParameters `type:"structure"`
// A CreateConnectionOAuthRequestParameters object that contains the OAuth authorization
// parameters to use for the connection.
OAuthParameters *CreateConnectionOAuthRequestParameters `type:"structure"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateConnectionAuthRequestParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateConnectionAuthRequestParameters) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateConnectionAuthRequestParameters) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "CreateConnectionAuthRequestParameters"}
if s.ApiKeyAuthParameters != nil {
if err := s.ApiKeyAuthParameters.Validate(); err != nil {
invalidParams.AddNested("ApiKeyAuthParameters", err.(request.ErrInvalidParams))
}
}
if s.BasicAuthParameters != nil {
if err := s.BasicAuthParameters.Validate(); err != nil {
invalidParams.AddNested("BasicAuthParameters", err.(request.ErrInvalidParams))
}
}
if s.OAuthParameters != nil {
if err := s.OAuthParameters.Validate(); err != nil {
invalidParams.AddNested("OAuthParameters", err.(request.ErrInvalidParams))
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApiKeyAuthParameters sets the ApiKeyAuthParameters field's value.
func (s *CreateConnectionAuthRequestParameters) SetApiKeyAuthParameters(v *CreateConnectionApiKeyAuthRequestParameters) *CreateConnectionAuthRequestParameters {
s.ApiKeyAuthParameters = v
return s
}
// SetBasicAuthParameters sets the BasicAuthParameters field's value.
func (s *CreateConnectionAuthRequestParameters) SetBasicAuthParameters(v *CreateConnectionBasicAuthRequestParameters) *CreateConnectionAuthRequestParameters {
s.BasicAuthParameters = v
return s
}
// SetInvocationHttpParameters sets the InvocationHttpParameters field's value.
func (s *CreateConnectionAuthRequestParameters) SetInvocationHttpParameters(v *ConnectionHttpParameters) *CreateConnectionAuthRequestParameters {
s.InvocationHttpParameters = v
return s
}
// SetOAuthParameters sets the OAuthParameters field's value.
func (s *CreateConnectionAuthRequestParameters) SetOAuthParameters(v *CreateConnectionOAuthRequestParameters) *CreateConnectionAuthRequestParameters {
s.OAuthParameters = v
return s
}
// Contains the Basic authorization parameters to use for the connection.
type CreateConnectionBasicAuthRequestParameters struct {
_ struct{} `type:"structure"`
// The password associated with the user name to use for Basic authorization.
//
// Password is a sensitive parameter and its value will be
// replaced with "sensitive" in string returned by CreateConnectionBasicAuthRequestParameters's
// String and GoString methods.
//
// Password is a required field
Password *string `min:"1" type:"string" required:"true" sensitive:"true"`
// The user name to use for Basic authorization.
//
// Username is a required field
Username *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateConnectionBasicAuthRequestParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateConnectionBasicAuthRequestParameters) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateConnectionBasicAuthRequestParameters) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "CreateConnectionBasicAuthRequestParameters"}
if s.Password == nil {
invalidParams.Add(request.NewErrParamRequired("Password"))
}
if s.Password != nil && len(*s.Password) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Password", 1))
}
if s.Username == nil {
invalidParams.Add(request.NewErrParamRequired("Username"))
}
if s.Username != nil && len(*s.Username) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Username", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetPassword sets the Password field's value.
func (s *CreateConnectionBasicAuthRequestParameters) SetPassword(v string) *CreateConnectionBasicAuthRequestParameters {
s.Password = &v
return s
}
// SetUsername sets the Username field's value.
func (s *CreateConnectionBasicAuthRequestParameters) SetUsername(v string) *CreateConnectionBasicAuthRequestParameters {
s.Username = &v
return s
}
type CreateConnectionInput struct {
_ struct{} `type:"structure"`
// A CreateConnectionAuthRequestParameters object that contains the authorization
// parameters to use to authorize with the endpoint.
//
// AuthParameters is a required field
AuthParameters *CreateConnectionAuthRequestParameters `type:"structure" required:"true"`
// The type of authorization to use for the connection.
//
// AuthorizationType is a required field
AuthorizationType *string `type:"string" required:"true" enum:"ConnectionAuthorizationType"`
// A description for the connection to create.
Description *string `type:"string"`
// The name for the connection to create.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateConnectionInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateConnectionInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateConnectionInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "CreateConnectionInput"}
if s.AuthParameters == nil {
invalidParams.Add(request.NewErrParamRequired("AuthParameters"))
}
if s.AuthorizationType == nil {
invalidParams.Add(request.NewErrParamRequired("AuthorizationType"))
}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if s.AuthParameters != nil {
if err := s.AuthParameters.Validate(); err != nil {
invalidParams.AddNested("AuthParameters", err.(request.ErrInvalidParams))
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetAuthParameters sets the AuthParameters field's value.
func (s *CreateConnectionInput) SetAuthParameters(v *CreateConnectionAuthRequestParameters) *CreateConnectionInput {
s.AuthParameters = v
return s
}
// SetAuthorizationType sets the AuthorizationType field's value.
func (s *CreateConnectionInput) SetAuthorizationType(v string) *CreateConnectionInput {
s.AuthorizationType = &v
return s
}
// SetDescription sets the Description field's value.
func (s *CreateConnectionInput) SetDescription(v string) *CreateConnectionInput {
s.Description = &v
return s
}
// SetName sets the Name field's value.
func (s *CreateConnectionInput) SetName(v string) *CreateConnectionInput {
s.Name = &v
return s
}
// Contains the Basic authorization parameters to use for the connection.
type CreateConnectionOAuthClientRequestParameters struct {
_ struct{} `type:"structure"`
// The client ID to use for OAuth authorization for the connection.
//
// ClientID is a required field
ClientID *string `min:"1" type:"string" required:"true"`
// The client secret associated with the client ID to use for OAuth authorization
// for the connection.
//
// ClientSecret is a sensitive parameter and its value will be
// replaced with "sensitive" in string returned by CreateConnectionOAuthClientRequestParameters's
// String and GoString methods.
//
// ClientSecret is a required field
ClientSecret *string `min:"1" type:"string" required:"true" sensitive:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateConnectionOAuthClientRequestParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateConnectionOAuthClientRequestParameters) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateConnectionOAuthClientRequestParameters) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "CreateConnectionOAuthClientRequestParameters"}
if s.ClientID == nil {
invalidParams.Add(request.NewErrParamRequired("ClientID"))
}
if s.ClientID != nil && len(*s.ClientID) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ClientID", 1))
}
if s.ClientSecret == nil {
invalidParams.Add(request.NewErrParamRequired("ClientSecret"))
}
if s.ClientSecret != nil && len(*s.ClientSecret) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ClientSecret", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetClientID sets the ClientID field's value.
func (s *CreateConnectionOAuthClientRequestParameters) SetClientID(v string) *CreateConnectionOAuthClientRequestParameters {
s.ClientID = &v
return s
}
// SetClientSecret sets the ClientSecret field's value.
func (s *CreateConnectionOAuthClientRequestParameters) SetClientSecret(v string) *CreateConnectionOAuthClientRequestParameters {
s.ClientSecret = &v
return s
}
// Contains the OAuth authorization parameters to use for the connection.
type CreateConnectionOAuthRequestParameters struct {
_ struct{} `type:"structure"`
// The URL to the authorization endpoint when OAuth is specified as the authorization
// type.
//
// AuthorizationEndpoint is a required field
AuthorizationEndpoint *string `min:"1" type:"string" required:"true"`
// A CreateConnectionOAuthClientRequestParameters object that contains the client
// parameters for OAuth authorization.
//
// ClientParameters is a required field
ClientParameters *CreateConnectionOAuthClientRequestParameters `type:"structure" required:"true"`
// The method to use for the authorization request.
//
// HttpMethod is a required field
HttpMethod *string `type:"string" required:"true" enum:"ConnectionOAuthHttpMethod"`
// A ConnectionHttpParameters object that contains details about the additional
// parameters to use for the connection.
OAuthHttpParameters *ConnectionHttpParameters `type:"structure"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateConnectionOAuthRequestParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateConnectionOAuthRequestParameters) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateConnectionOAuthRequestParameters) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "CreateConnectionOAuthRequestParameters"}
if s.AuthorizationEndpoint == nil {
invalidParams.Add(request.NewErrParamRequired("AuthorizationEndpoint"))
}
if s.AuthorizationEndpoint != nil && len(*s.AuthorizationEndpoint) < 1 {
invalidParams.Add(request.NewErrParamMinLen("AuthorizationEndpoint", 1))
}
if s.ClientParameters == nil {
invalidParams.Add(request.NewErrParamRequired("ClientParameters"))
}
if s.HttpMethod == nil {
invalidParams.Add(request.NewErrParamRequired("HttpMethod"))
}
if s.ClientParameters != nil {
if err := s.ClientParameters.Validate(); err != nil {
invalidParams.AddNested("ClientParameters", err.(request.ErrInvalidParams))
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetAuthorizationEndpoint sets the AuthorizationEndpoint field's value.
func (s *CreateConnectionOAuthRequestParameters) SetAuthorizationEndpoint(v string) *CreateConnectionOAuthRequestParameters {
s.AuthorizationEndpoint = &v
return s
}
// SetClientParameters sets the ClientParameters field's value.
func (s *CreateConnectionOAuthRequestParameters) SetClientParameters(v *CreateConnectionOAuthClientRequestParameters) *CreateConnectionOAuthRequestParameters {
s.ClientParameters = v
return s
}
// SetHttpMethod sets the HttpMethod field's value.
func (s *CreateConnectionOAuthRequestParameters) SetHttpMethod(v string) *CreateConnectionOAuthRequestParameters {
s.HttpMethod = &v
return s
}
// SetOAuthHttpParameters sets the OAuthHttpParameters field's value.
func (s *CreateConnectionOAuthRequestParameters) SetOAuthHttpParameters(v *ConnectionHttpParameters) *CreateConnectionOAuthRequestParameters {
s.OAuthHttpParameters = v
return s
}
type CreateConnectionOutput struct {
_ struct{} `type:"structure"`
// The ARN of the connection that was created by the request.
ConnectionArn *string `min:"1" type:"string"`
// The state of the connection that was created by the request.
ConnectionState *string `type:"string" enum:"ConnectionState"`
// A time stamp for the time that the connection was created.
CreationTime *time.Time `type:"timestamp"`
// A time stamp for the time that the connection was last updated.
LastModifiedTime *time.Time `type:"timestamp"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateConnectionOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateConnectionOutput) GoString() string {
return s.String()
}
// SetConnectionArn sets the ConnectionArn field's value.
func (s *CreateConnectionOutput) SetConnectionArn(v string) *CreateConnectionOutput {
s.ConnectionArn = &v
return s
}
// SetConnectionState sets the ConnectionState field's value.
func (s *CreateConnectionOutput) SetConnectionState(v string) *CreateConnectionOutput {
s.ConnectionState = &v
return s
}
// SetCreationTime sets the CreationTime field's value.
func (s *CreateConnectionOutput) SetCreationTime(v time.Time) *CreateConnectionOutput {
s.CreationTime = &v
return s
}
// SetLastModifiedTime sets the LastModifiedTime field's value.
func (s *CreateConnectionOutput) SetLastModifiedTime(v time.Time) *CreateConnectionOutput {
s.LastModifiedTime = &v
return s
}
type CreateEventBusInput struct {
_ struct{} `type:"structure"`
// If you are creating a partner event bus, this specifies the partner event
// source that the new event bus will be matched with.
EventSourceName *string `min:"1" type:"string"`
// The name of the new event bus.
//
// Event bus names cannot contain the / character. You can't use the name default
// for a custom event bus, as this name is already used for your account's default
// event bus.
//
// If this is a partner event bus, the name must exactly match the name of the
// partner event source that this event bus is matched to.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
// Tags to associate with the event bus.
Tags []*Tag `type:"list"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateEventBusInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateEventBusInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateEventBusInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "CreateEventBusInput"}
if s.EventSourceName != nil && len(*s.EventSourceName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("EventSourceName", 1))
}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if s.Tags != nil {
for i, v := range s.Tags {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetEventSourceName sets the EventSourceName field's value.
func (s *CreateEventBusInput) SetEventSourceName(v string) *CreateEventBusInput {
s.EventSourceName = &v
return s
}
// SetName sets the Name field's value.
func (s *CreateEventBusInput) SetName(v string) *CreateEventBusInput {
s.Name = &v
return s
}
// SetTags sets the Tags field's value.
func (s *CreateEventBusInput) SetTags(v []*Tag) *CreateEventBusInput {
s.Tags = v
return s
}
type CreateEventBusOutput struct {
_ struct{} `type:"structure"`
// The ARN of the new event bus.
EventBusArn *string `type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateEventBusOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreateEventBusOutput) GoString() string {
return s.String()
}
// SetEventBusArn sets the EventBusArn field's value.
func (s *CreateEventBusOutput) SetEventBusArn(v string) *CreateEventBusOutput {
s.EventBusArn = &v
return s
}
type CreatePartnerEventSourceInput struct {
_ struct{} `type:"structure"`
// The Amazon Web Services account ID that is permitted to create a matching
// partner event bus for this partner event source.
//
// Account is a required field
Account *string `min:"12" type:"string" required:"true"`
// The name of the partner event source. This name must be unique and must be
// in the format partner_name/event_namespace/event_name . The Amazon Web Services
// account that wants to use this partner event source must create a partner
// event bus with a name that matches the name of the partner event source.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreatePartnerEventSourceInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreatePartnerEventSourceInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *CreatePartnerEventSourceInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "CreatePartnerEventSourceInput"}
if s.Account == nil {
invalidParams.Add(request.NewErrParamRequired("Account"))
}
if s.Account != nil && len(*s.Account) < 12 {
invalidParams.Add(request.NewErrParamMinLen("Account", 12))
}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetAccount sets the Account field's value.
func (s *CreatePartnerEventSourceInput) SetAccount(v string) *CreatePartnerEventSourceInput {
s.Account = &v
return s
}
// SetName sets the Name field's value.
func (s *CreatePartnerEventSourceInput) SetName(v string) *CreatePartnerEventSourceInput {
s.Name = &v
return s
}
type CreatePartnerEventSourceOutput struct {
_ struct{} `type:"structure"`
// The ARN of the partner event source.
EventSourceArn *string `type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreatePartnerEventSourceOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s CreatePartnerEventSourceOutput) GoString() string {
return s.String()
}
// SetEventSourceArn sets the EventSourceArn field's value.
func (s *CreatePartnerEventSourceOutput) SetEventSourceArn(v string) *CreatePartnerEventSourceOutput {
s.EventSourceArn = &v
return s
}
type DeactivateEventSourceInput struct {
_ struct{} `type:"structure"`
// The name of the partner event source to deactivate.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeactivateEventSourceInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeactivateEventSourceInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeactivateEventSourceInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeactivateEventSourceInput"}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetName sets the Name field's value.
func (s *DeactivateEventSourceInput) SetName(v string) *DeactivateEventSourceInput {
s.Name = &v
return s
}
type DeactivateEventSourceOutput struct {
_ struct{} `type:"structure"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeactivateEventSourceOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeactivateEventSourceOutput) GoString() string {
return s.String()
}
// A DeadLetterConfig object that contains information about a dead-letter queue
// configuration.
type DeadLetterConfig struct {
_ struct{} `type:"structure"`
// The ARN of the SQS queue specified as the target for the dead-letter queue.
Arn *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeadLetterConfig) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeadLetterConfig) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeadLetterConfig) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeadLetterConfig"}
if s.Arn != nil && len(*s.Arn) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Arn", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetArn sets the Arn field's value.
func (s *DeadLetterConfig) SetArn(v string) *DeadLetterConfig {
s.Arn = &v
return s
}
type DeauthorizeConnectionInput struct {
_ struct{} `type:"structure"`
// The name of the connection to remove authorization from.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeauthorizeConnectionInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeauthorizeConnectionInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeauthorizeConnectionInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeauthorizeConnectionInput"}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetName sets the Name field's value.
func (s *DeauthorizeConnectionInput) SetName(v string) *DeauthorizeConnectionInput {
s.Name = &v
return s
}
type DeauthorizeConnectionOutput struct {
_ struct{} `type:"structure"`
// The ARN of the connection that authorization was removed from.
ConnectionArn *string `min:"1" type:"string"`
// The state of the connection.
ConnectionState *string `type:"string" enum:"ConnectionState"`
// A time stamp for the time that the connection was created.
CreationTime *time.Time `type:"timestamp"`
// A time stamp for the time that the connection was last authorized.
LastAuthorizedTime *time.Time `type:"timestamp"`
// A time stamp for the time that the connection was last updated.
LastModifiedTime *time.Time `type:"timestamp"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeauthorizeConnectionOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeauthorizeConnectionOutput) GoString() string {
return s.String()
}
// SetConnectionArn sets the ConnectionArn field's value.
func (s *DeauthorizeConnectionOutput) SetConnectionArn(v string) *DeauthorizeConnectionOutput {
s.ConnectionArn = &v
return s
}
// SetConnectionState sets the ConnectionState field's value.
func (s *DeauthorizeConnectionOutput) SetConnectionState(v string) *DeauthorizeConnectionOutput {
s.ConnectionState = &v
return s
}
// SetCreationTime sets the CreationTime field's value.
func (s *DeauthorizeConnectionOutput) SetCreationTime(v time.Time) *DeauthorizeConnectionOutput {
s.CreationTime = &v
return s
}
// SetLastAuthorizedTime sets the LastAuthorizedTime field's value.
func (s *DeauthorizeConnectionOutput) SetLastAuthorizedTime(v time.Time) *DeauthorizeConnectionOutput {
s.LastAuthorizedTime = &v
return s
}
// SetLastModifiedTime sets the LastModifiedTime field's value.
func (s *DeauthorizeConnectionOutput) SetLastModifiedTime(v time.Time) *DeauthorizeConnectionOutput {
s.LastModifiedTime = &v
return s
}
type DeleteApiDestinationInput struct {
_ struct{} `type:"structure"`
// The name of the destination to delete.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeleteApiDestinationInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeleteApiDestinationInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteApiDestinationInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeleteApiDestinationInput"}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetName sets the Name field's value.
func (s *DeleteApiDestinationInput) SetName(v string) *DeleteApiDestinationInput {
s.Name = &v
return s
}
type DeleteApiDestinationOutput struct {
_ struct{} `type:"structure"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeleteApiDestinationOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeleteApiDestinationOutput) GoString() string {
return s.String()
}
type DeleteArchiveInput struct {
_ struct{} `type:"structure"`
// The name of the archive to delete.
//
// ArchiveName is a required field
ArchiveName *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeleteArchiveInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeleteArchiveInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteArchiveInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeleteArchiveInput"}
if s.ArchiveName == nil {
invalidParams.Add(request.NewErrParamRequired("ArchiveName"))
}
if s.ArchiveName != nil && len(*s.ArchiveName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ArchiveName", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetArchiveName sets the ArchiveName field's value.
func (s *DeleteArchiveInput) SetArchiveName(v string) *DeleteArchiveInput {
s.ArchiveName = &v
return s
}
type DeleteArchiveOutput struct {
_ struct{} `type:"structure"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeleteArchiveOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeleteArchiveOutput) GoString() string {
return s.String()
}
type DeleteConnectionInput struct {
_ struct{} `type:"structure"`
// The name of the connection to delete.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeleteConnectionInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeleteConnectionInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteConnectionInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeleteConnectionInput"}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetName sets the Name field's value.
func (s *DeleteConnectionInput) SetName(v string) *DeleteConnectionInput {
s.Name = &v
return s
}
type DeleteConnectionOutput struct {
_ struct{} `type:"structure"`
// The ARN of the connection that was deleted.
ConnectionArn *string `min:"1" type:"string"`
// The state of the connection before it was deleted.
ConnectionState *string `type:"string" enum:"ConnectionState"`
// A time stamp for the time that the connection was created.
CreationTime *time.Time `type:"timestamp"`
// A time stamp for the time that the connection was last authorized before
// it wa deleted.
LastAuthorizedTime *time.Time `type:"timestamp"`
// A time stamp for the time that the connection was last modified before it
// was deleted.
LastModifiedTime *time.Time `type:"timestamp"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeleteConnectionOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeleteConnectionOutput) GoString() string {
return s.String()
}
// SetConnectionArn sets the ConnectionArn field's value.
func (s *DeleteConnectionOutput) SetConnectionArn(v string) *DeleteConnectionOutput {
s.ConnectionArn = &v
return s
}
// SetConnectionState sets the ConnectionState field's value.
func (s *DeleteConnectionOutput) SetConnectionState(v string) *DeleteConnectionOutput {
s.ConnectionState = &v
return s
}
// SetCreationTime sets the CreationTime field's value.
func (s *DeleteConnectionOutput) SetCreationTime(v time.Time) *DeleteConnectionOutput {
s.CreationTime = &v
return s
}
// SetLastAuthorizedTime sets the LastAuthorizedTime field's value.
func (s *DeleteConnectionOutput) SetLastAuthorizedTime(v time.Time) *DeleteConnectionOutput {
s.LastAuthorizedTime = &v
return s
}
// SetLastModifiedTime sets the LastModifiedTime field's value.
func (s *DeleteConnectionOutput) SetLastModifiedTime(v time.Time) *DeleteConnectionOutput {
s.LastModifiedTime = &v
return s
}
type DeleteEventBusInput struct {
_ struct{} `type:"structure"`
// The name of the event bus to delete.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeleteEventBusInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeleteEventBusInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteEventBusInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeleteEventBusInput"}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetName sets the Name field's value.
func (s *DeleteEventBusInput) SetName(v string) *DeleteEventBusInput {
s.Name = &v
return s
}
type DeleteEventBusOutput struct {
_ struct{} `type:"structure"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeleteEventBusOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeleteEventBusOutput) GoString() string {
return s.String()
}
type DeletePartnerEventSourceInput struct {
_ struct{} `type:"structure"`
// The Amazon Web Services account ID of the Amazon Web Services customer that
// the event source was created for.
//
// Account is a required field
Account *string `min:"12" type:"string" required:"true"`
// The name of the event source to delete.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeletePartnerEventSourceInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeletePartnerEventSourceInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeletePartnerEventSourceInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeletePartnerEventSourceInput"}
if s.Account == nil {
invalidParams.Add(request.NewErrParamRequired("Account"))
}
if s.Account != nil && len(*s.Account) < 12 {
invalidParams.Add(request.NewErrParamMinLen("Account", 12))
}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetAccount sets the Account field's value.
func (s *DeletePartnerEventSourceInput) SetAccount(v string) *DeletePartnerEventSourceInput {
s.Account = &v
return s
}
// SetName sets the Name field's value.
func (s *DeletePartnerEventSourceInput) SetName(v string) *DeletePartnerEventSourceInput {
s.Name = &v
return s
}
type DeletePartnerEventSourceOutput struct {
_ struct{} `type:"structure"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeletePartnerEventSourceOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeletePartnerEventSourceOutput) GoString() string {
return s.String()
}
type DeleteRuleInput struct {
_ struct{} `type:"structure"`
// The name or ARN of the event bus associated with the rule. If you omit this,
// the default event bus is used.
EventBusName *string `min:"1" type:"string"`
// If this is a managed rule, created by an Amazon Web Services service on your
// behalf, you must specify Force as True to delete the rule. This parameter
// is ignored for rules that are not managed rules. You can check whether a
// rule is a managed rule by using DescribeRule or ListRules and checking the
// ManagedBy field of the response.
Force *bool `type:"boolean"`
// The name of the rule.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeleteRuleInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeleteRuleInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteRuleInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeleteRuleInput"}
if s.EventBusName != nil && len(*s.EventBusName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("EventBusName", 1))
}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetEventBusName sets the EventBusName field's value.
func (s *DeleteRuleInput) SetEventBusName(v string) *DeleteRuleInput {
s.EventBusName = &v
return s
}
// SetForce sets the Force field's value.
func (s *DeleteRuleInput) SetForce(v bool) *DeleteRuleInput {
s.Force = &v
return s
}
// SetName sets the Name field's value.
func (s *DeleteRuleInput) SetName(v string) *DeleteRuleInput {
s.Name = &v
return s
}
type DeleteRuleOutput struct {
_ struct{} `type:"structure"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeleteRuleOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DeleteRuleOutput) GoString() string {
return s.String()
}
type DescribeApiDestinationInput struct {
_ struct{} `type:"structure"`
// The name of the API destination to retrieve.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeApiDestinationInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeApiDestinationInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeApiDestinationInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DescribeApiDestinationInput"}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetName sets the Name field's value.
func (s *DescribeApiDestinationInput) SetName(v string) *DescribeApiDestinationInput {
s.Name = &v
return s
}
type DescribeApiDestinationOutput struct {
_ struct{} `type:"structure"`
// The ARN of the API destination retrieved.
ApiDestinationArn *string `min:"1" type:"string"`
// The state of the API destination retrieved.
ApiDestinationState *string `type:"string" enum:"ApiDestinationState"`
// The ARN of the connection specified for the API destination retrieved.
ConnectionArn *string `min:"1" type:"string"`
// A time stamp for the time that the API destination was created.
CreationTime *time.Time `type:"timestamp"`
// The description for the API destination retrieved.
Description *string `type:"string"`
// The method to use to connect to the HTTP endpoint.
HttpMethod *string `type:"string" enum:"ApiDestinationHttpMethod"`
// The URL to use to connect to the HTTP endpoint.
InvocationEndpoint *string `min:"1" type:"string"`
// The maximum number of invocations per second to specified for the API destination.
// Note that if you set the invocation rate maximum to a value lower the rate
// necessary to send all events received on to the destination HTTP endpoint,
// some events may not be delivered within the 24-hour retry window. If you
// plan to set the rate lower than the rate necessary to deliver all events,
// consider using a dead-letter queue to catch events that are not delivered
// within 24 hours.
InvocationRateLimitPerSecond *int64 `min:"1" type:"integer"`
// A time stamp for the time that the API destination was last modified.
LastModifiedTime *time.Time `type:"timestamp"`
// The name of the API destination retrieved.
Name *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeApiDestinationOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeApiDestinationOutput) GoString() string {
return s.String()
}
// SetApiDestinationArn sets the ApiDestinationArn field's value.
func (s *DescribeApiDestinationOutput) SetApiDestinationArn(v string) *DescribeApiDestinationOutput {
s.ApiDestinationArn = &v
return s
}
// SetApiDestinationState sets the ApiDestinationState field's value.
func (s *DescribeApiDestinationOutput) SetApiDestinationState(v string) *DescribeApiDestinationOutput {
s.ApiDestinationState = &v
return s
}
// SetConnectionArn sets the ConnectionArn field's value.
func (s *DescribeApiDestinationOutput) SetConnectionArn(v string) *DescribeApiDestinationOutput {
s.ConnectionArn = &v
return s
}
// SetCreationTime sets the CreationTime field's value.
func (s *DescribeApiDestinationOutput) SetCreationTime(v time.Time) *DescribeApiDestinationOutput {
s.CreationTime = &v
return s
}
// SetDescription sets the Description field's value.
func (s *DescribeApiDestinationOutput) SetDescription(v string) *DescribeApiDestinationOutput {
s.Description = &v
return s
}
// SetHttpMethod sets the HttpMethod field's value.
func (s *DescribeApiDestinationOutput) SetHttpMethod(v string) *DescribeApiDestinationOutput {
s.HttpMethod = &v
return s
}
// SetInvocationEndpoint sets the InvocationEndpoint field's value.
func (s *DescribeApiDestinationOutput) SetInvocationEndpoint(v string) *DescribeApiDestinationOutput {
s.InvocationEndpoint = &v
return s
}
// SetInvocationRateLimitPerSecond sets the InvocationRateLimitPerSecond field's value.
func (s *DescribeApiDestinationOutput) SetInvocationRateLimitPerSecond(v int64) *DescribeApiDestinationOutput {
s.InvocationRateLimitPerSecond = &v
return s
}
// SetLastModifiedTime sets the LastModifiedTime field's value.
func (s *DescribeApiDestinationOutput) SetLastModifiedTime(v time.Time) *DescribeApiDestinationOutput {
s.LastModifiedTime = &v
return s
}
// SetName sets the Name field's value.
func (s *DescribeApiDestinationOutput) SetName(v string) *DescribeApiDestinationOutput {
s.Name = &v
return s
}
type DescribeArchiveInput struct {
_ struct{} `type:"structure"`
// The name of the archive to retrieve.
//
// ArchiveName is a required field
ArchiveName *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeArchiveInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeArchiveInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeArchiveInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DescribeArchiveInput"}
if s.ArchiveName == nil {
invalidParams.Add(request.NewErrParamRequired("ArchiveName"))
}
if s.ArchiveName != nil && len(*s.ArchiveName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ArchiveName", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetArchiveName sets the ArchiveName field's value.
func (s *DescribeArchiveInput) SetArchiveName(v string) *DescribeArchiveInput {
s.ArchiveName = &v
return s
}
type DescribeArchiveOutput struct {
_ struct{} `type:"structure"`
// The ARN of the archive.
ArchiveArn *string `min:"1" type:"string"`
// The name of the archive.
ArchiveName *string `min:"1" type:"string"`
// The time at which the archive was created.
CreationTime *time.Time `type:"timestamp"`
// The description of the archive.
Description *string `type:"string"`
// The number of events in the archive.
EventCount *int64 `type:"long"`
// The event pattern used to filter events sent to the archive.
EventPattern *string `type:"string"`
// The ARN of the event source associated with the archive.
EventSourceArn *string `min:"1" type:"string"`
// The number of days to retain events for in the archive.
RetentionDays *int64 `type:"integer"`
// The size of the archive in bytes.
SizeBytes *int64 `type:"long"`
// The state of the archive.
State *string `type:"string" enum:"ArchiveState"`
// The reason that the archive is in the state.
StateReason *string `type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeArchiveOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeArchiveOutput) GoString() string {
return s.String()
}
// SetArchiveArn sets the ArchiveArn field's value.
func (s *DescribeArchiveOutput) SetArchiveArn(v string) *DescribeArchiveOutput {
s.ArchiveArn = &v
return s
}
// SetArchiveName sets the ArchiveName field's value.
func (s *DescribeArchiveOutput) SetArchiveName(v string) *DescribeArchiveOutput {
s.ArchiveName = &v
return s
}
// SetCreationTime sets the CreationTime field's value.
func (s *DescribeArchiveOutput) SetCreationTime(v time.Time) *DescribeArchiveOutput {
s.CreationTime = &v
return s
}
// SetDescription sets the Description field's value.
func (s *DescribeArchiveOutput) SetDescription(v string) *DescribeArchiveOutput {
s.Description = &v
return s
}
// SetEventCount sets the EventCount field's value.
func (s *DescribeArchiveOutput) SetEventCount(v int64) *DescribeArchiveOutput {
s.EventCount = &v
return s
}
// SetEventPattern sets the EventPattern field's value.
func (s *DescribeArchiveOutput) SetEventPattern(v string) *DescribeArchiveOutput {
s.EventPattern = &v
return s
}
// SetEventSourceArn sets the EventSourceArn field's value.
func (s *DescribeArchiveOutput) SetEventSourceArn(v string) *DescribeArchiveOutput {
s.EventSourceArn = &v
return s
}
// SetRetentionDays sets the RetentionDays field's value.
func (s *DescribeArchiveOutput) SetRetentionDays(v int64) *DescribeArchiveOutput {
s.RetentionDays = &v
return s
}
// SetSizeBytes sets the SizeBytes field's value.
func (s *DescribeArchiveOutput) SetSizeBytes(v int64) *DescribeArchiveOutput {
s.SizeBytes = &v
return s
}
// SetState sets the State field's value.
func (s *DescribeArchiveOutput) SetState(v string) *DescribeArchiveOutput {
s.State = &v
return s
}
// SetStateReason sets the StateReason field's value.
func (s *DescribeArchiveOutput) SetStateReason(v string) *DescribeArchiveOutput {
s.StateReason = &v
return s
}
type DescribeConnectionInput struct {
_ struct{} `type:"structure"`
// The name of the connection to retrieve.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeConnectionInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeConnectionInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeConnectionInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DescribeConnectionInput"}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetName sets the Name field's value.
func (s *DescribeConnectionInput) SetName(v string) *DescribeConnectionInput {
s.Name = &v
return s
}
type DescribeConnectionOutput struct {
_ struct{} `type:"structure"`
// The parameters to use for authorization for the connection.
AuthParameters *ConnectionAuthResponseParameters `type:"structure"`
// The type of authorization specified for the connection.
AuthorizationType *string `type:"string" enum:"ConnectionAuthorizationType"`
// The ARN of the connection retrieved.
ConnectionArn *string `min:"1" type:"string"`
// The state of the connection retrieved.
ConnectionState *string `type:"string" enum:"ConnectionState"`
// A time stamp for the time that the connection was created.
CreationTime *time.Time `type:"timestamp"`
// The description for the connection retrieved.
Description *string `type:"string"`
// A time stamp for the time that the connection was last authorized.
LastAuthorizedTime *time.Time `type:"timestamp"`
// A time stamp for the time that the connection was last modified.
LastModifiedTime *time.Time `type:"timestamp"`
// The name of the connection retrieved.
Name *string `min:"1" type:"string"`
// The ARN of the secret created from the authorization parameters specified
// for the connection.
SecretArn *string `min:"20" type:"string"`
// The reason that the connection is in the current connection state.
StateReason *string `type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeConnectionOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeConnectionOutput) GoString() string {
return s.String()
}
// SetAuthParameters sets the AuthParameters field's value.
func (s *DescribeConnectionOutput) SetAuthParameters(v *ConnectionAuthResponseParameters) *DescribeConnectionOutput {
s.AuthParameters = v
return s
}
// SetAuthorizationType sets the AuthorizationType field's value.
func (s *DescribeConnectionOutput) SetAuthorizationType(v string) *DescribeConnectionOutput {
s.AuthorizationType = &v
return s
}
// SetConnectionArn sets the ConnectionArn field's value.
func (s *DescribeConnectionOutput) SetConnectionArn(v string) *DescribeConnectionOutput {
s.ConnectionArn = &v
return s
}
// SetConnectionState sets the ConnectionState field's value.
func (s *DescribeConnectionOutput) SetConnectionState(v string) *DescribeConnectionOutput {
s.ConnectionState = &v
return s
}
// SetCreationTime sets the CreationTime field's value.
func (s *DescribeConnectionOutput) SetCreationTime(v time.Time) *DescribeConnectionOutput {
s.CreationTime = &v
return s
}
// SetDescription sets the Description field's value.
func (s *DescribeConnectionOutput) SetDescription(v string) *DescribeConnectionOutput {
s.Description = &v
return s
}
// SetLastAuthorizedTime sets the LastAuthorizedTime field's value.
func (s *DescribeConnectionOutput) SetLastAuthorizedTime(v time.Time) *DescribeConnectionOutput {
s.LastAuthorizedTime = &v
return s
}
// SetLastModifiedTime sets the LastModifiedTime field's value.
func (s *DescribeConnectionOutput) SetLastModifiedTime(v time.Time) *DescribeConnectionOutput {
s.LastModifiedTime = &v
return s
}
// SetName sets the Name field's value.
func (s *DescribeConnectionOutput) SetName(v string) *DescribeConnectionOutput {
s.Name = &v
return s
}
// SetSecretArn sets the SecretArn field's value.
func (s *DescribeConnectionOutput) SetSecretArn(v string) *DescribeConnectionOutput {
s.SecretArn = &v
return s
}
// SetStateReason sets the StateReason field's value.
func (s *DescribeConnectionOutput) SetStateReason(v string) *DescribeConnectionOutput {
s.StateReason = &v
return s
}
type DescribeEventBusInput struct {
_ struct{} `type:"structure"`
// The name or ARN of the event bus to show details for. If you omit this, the
// default event bus is displayed.
Name *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeEventBusInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeEventBusInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeEventBusInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DescribeEventBusInput"}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetName sets the Name field's value.
func (s *DescribeEventBusInput) SetName(v string) *DescribeEventBusInput {
s.Name = &v
return s
}
type DescribeEventBusOutput struct {
_ struct{} `type:"structure"`
// The Amazon Resource Name (ARN) of the account permitted to write events to
// the current account.
Arn *string `type:"string"`
// The name of the event bus. Currently, this is always default.
Name *string `type:"string"`
// The policy that enables the external account to send events to your account.
Policy *string `type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeEventBusOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeEventBusOutput) GoString() string {
return s.String()
}
// SetArn sets the Arn field's value.
func (s *DescribeEventBusOutput) SetArn(v string) *DescribeEventBusOutput {
s.Arn = &v
return s
}
// SetName sets the Name field's value.
func (s *DescribeEventBusOutput) SetName(v string) *DescribeEventBusOutput {
s.Name = &v
return s
}
// SetPolicy sets the Policy field's value.
func (s *DescribeEventBusOutput) SetPolicy(v string) *DescribeEventBusOutput {
s.Policy = &v
return s
}
type DescribeEventSourceInput struct {
_ struct{} `type:"structure"`
// The name of the partner event source to display the details of.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeEventSourceInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeEventSourceInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeEventSourceInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DescribeEventSourceInput"}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetName sets the Name field's value.
func (s *DescribeEventSourceInput) SetName(v string) *DescribeEventSourceInput {
s.Name = &v
return s
}
type DescribeEventSourceOutput struct {
_ struct{} `type:"structure"`
// The ARN of the partner event source.
Arn *string `type:"string"`
// The name of the SaaS partner that created the event source.
CreatedBy *string `type:"string"`
// The date and time that the event source was created.
CreationTime *time.Time `type:"timestamp"`
// The date and time that the event source will expire if you do not create
// a matching event bus.
ExpirationTime *time.Time `type:"timestamp"`
// The name of the partner event source.
Name *string `type:"string"`
// The state of the event source. If it is ACTIVE, you have already created
// a matching event bus for this event source, and that event bus is active.
// If it is PENDING, either you haven't yet created a matching event bus, or
// that event bus is deactivated. If it is DELETED, you have created a matching
// event bus, but the event source has since been deleted.
State *string `type:"string" enum:"EventSourceState"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeEventSourceOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeEventSourceOutput) GoString() string {
return s.String()
}
// SetArn sets the Arn field's value.
func (s *DescribeEventSourceOutput) SetArn(v string) *DescribeEventSourceOutput {
s.Arn = &v
return s
}
// SetCreatedBy sets the CreatedBy field's value.
func (s *DescribeEventSourceOutput) SetCreatedBy(v string) *DescribeEventSourceOutput {
s.CreatedBy = &v
return s
}
// SetCreationTime sets the CreationTime field's value.
func (s *DescribeEventSourceOutput) SetCreationTime(v time.Time) *DescribeEventSourceOutput {
s.CreationTime = &v
return s
}
// SetExpirationTime sets the ExpirationTime field's value.
func (s *DescribeEventSourceOutput) SetExpirationTime(v time.Time) *DescribeEventSourceOutput {
s.ExpirationTime = &v
return s
}
// SetName sets the Name field's value.
func (s *DescribeEventSourceOutput) SetName(v string) *DescribeEventSourceOutput {
s.Name = &v
return s
}
// SetState sets the State field's value.
func (s *DescribeEventSourceOutput) SetState(v string) *DescribeEventSourceOutput {
s.State = &v
return s
}
type DescribePartnerEventSourceInput struct {
_ struct{} `type:"structure"`
// The name of the event source to display.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribePartnerEventSourceInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribePartnerEventSourceInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribePartnerEventSourceInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DescribePartnerEventSourceInput"}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetName sets the Name field's value.
func (s *DescribePartnerEventSourceInput) SetName(v string) *DescribePartnerEventSourceInput {
s.Name = &v
return s
}
type DescribePartnerEventSourceOutput struct {
_ struct{} `type:"structure"`
// The ARN of the event source.
Arn *string `type:"string"`
// The name of the event source.
Name *string `type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribePartnerEventSourceOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribePartnerEventSourceOutput) GoString() string {
return s.String()
}
// SetArn sets the Arn field's value.
func (s *DescribePartnerEventSourceOutput) SetArn(v string) *DescribePartnerEventSourceOutput {
s.Arn = &v
return s
}
// SetName sets the Name field's value.
func (s *DescribePartnerEventSourceOutput) SetName(v string) *DescribePartnerEventSourceOutput {
s.Name = &v
return s
}
type DescribeReplayInput struct {
_ struct{} `type:"structure"`
// The name of the replay to retrieve.
//
// ReplayName is a required field
ReplayName *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeReplayInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeReplayInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeReplayInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DescribeReplayInput"}
if s.ReplayName == nil {
invalidParams.Add(request.NewErrParamRequired("ReplayName"))
}
if s.ReplayName != nil && len(*s.ReplayName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ReplayName", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetReplayName sets the ReplayName field's value.
func (s *DescribeReplayInput) SetReplayName(v string) *DescribeReplayInput {
s.ReplayName = &v
return s
}
type DescribeReplayOutput struct {
_ struct{} `type:"structure"`
// The description of the replay.
Description *string `type:"string"`
// A ReplayDestination object that contains details about the replay.
Destination *ReplayDestination `type:"structure"`
// The time stamp for the last event that was replayed from the archive.
EventEndTime *time.Time `type:"timestamp"`
// The time that the event was last replayed.
EventLastReplayedTime *time.Time `type:"timestamp"`
// The ARN of the archive events were replayed from.
EventSourceArn *string `min:"1" type:"string"`
// The time stamp of the first event that was last replayed from the archive.
EventStartTime *time.Time `type:"timestamp"`
// The ARN of the replay.
ReplayArn *string `min:"1" type:"string"`
// A time stamp for the time that the replay stopped.
ReplayEndTime *time.Time `type:"timestamp"`
// The name of the replay.
ReplayName *string `min:"1" type:"string"`
// A time stamp for the time that the replay started.
ReplayStartTime *time.Time `type:"timestamp"`
// The current state of the replay.
State *string `type:"string" enum:"ReplayState"`
// The reason that the replay is in the current state.
StateReason *string `type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeReplayOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeReplayOutput) GoString() string {
return s.String()
}
// SetDescription sets the Description field's value.
func (s *DescribeReplayOutput) SetDescription(v string) *DescribeReplayOutput {
s.Description = &v
return s
}
// SetDestination sets the Destination field's value.
func (s *DescribeReplayOutput) SetDestination(v *ReplayDestination) *DescribeReplayOutput {
s.Destination = v
return s
}
// SetEventEndTime sets the EventEndTime field's value.
func (s *DescribeReplayOutput) SetEventEndTime(v time.Time) *DescribeReplayOutput {
s.EventEndTime = &v
return s
}
// SetEventLastReplayedTime sets the EventLastReplayedTime field's value.
func (s *DescribeReplayOutput) SetEventLastReplayedTime(v time.Time) *DescribeReplayOutput {
s.EventLastReplayedTime = &v
return s
}
// SetEventSourceArn sets the EventSourceArn field's value.
func (s *DescribeReplayOutput) SetEventSourceArn(v string) *DescribeReplayOutput {
s.EventSourceArn = &v
return s
}
// SetEventStartTime sets the EventStartTime field's value.
func (s *DescribeReplayOutput) SetEventStartTime(v time.Time) *DescribeReplayOutput {
s.EventStartTime = &v
return s
}
// SetReplayArn sets the ReplayArn field's value.
func (s *DescribeReplayOutput) SetReplayArn(v string) *DescribeReplayOutput {
s.ReplayArn = &v
return s
}
// SetReplayEndTime sets the ReplayEndTime field's value.
func (s *DescribeReplayOutput) SetReplayEndTime(v time.Time) *DescribeReplayOutput {
s.ReplayEndTime = &v
return s
}
// SetReplayName sets the ReplayName field's value.
func (s *DescribeReplayOutput) SetReplayName(v string) *DescribeReplayOutput {
s.ReplayName = &v
return s
}
// SetReplayStartTime sets the ReplayStartTime field's value.
func (s *DescribeReplayOutput) SetReplayStartTime(v time.Time) *DescribeReplayOutput {
s.ReplayStartTime = &v
return s
}
// SetState sets the State field's value.
func (s *DescribeReplayOutput) SetState(v string) *DescribeReplayOutput {
s.State = &v
return s
}
// SetStateReason sets the StateReason field's value.
func (s *DescribeReplayOutput) SetStateReason(v string) *DescribeReplayOutput {
s.StateReason = &v
return s
}
type DescribeRuleInput struct {
_ struct{} `type:"structure"`
// The name or ARN of the event bus associated with the rule. If you omit this,
// the default event bus is used.
EventBusName *string `min:"1" type:"string"`
// The name of the rule.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeRuleInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeRuleInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeRuleInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DescribeRuleInput"}
if s.EventBusName != nil && len(*s.EventBusName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("EventBusName", 1))
}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetEventBusName sets the EventBusName field's value.
func (s *DescribeRuleInput) SetEventBusName(v string) *DescribeRuleInput {
s.EventBusName = &v
return s
}
// SetName sets the Name field's value.
func (s *DescribeRuleInput) SetName(v string) *DescribeRuleInput {
s.Name = &v
return s
}
type DescribeRuleOutput struct {
_ struct{} `type:"structure"`
// The Amazon Resource Name (ARN) of the rule.
Arn *string `min:"1" type:"string"`
// The account ID of the user that created the rule. If you use PutRule to put
// a rule on an event bus in another account, the other account is the owner
// of the rule, and the rule ARN includes the account ID for that account. However,
// the value for CreatedBy is the account ID as the account that created the
// rule in the other account.
CreatedBy *string `min:"1" type:"string"`
// The description of the rule.
Description *string `type:"string"`
// The name of the event bus associated with the rule.
EventBusName *string `min:"1" type:"string"`
// The event pattern. For more information, see Events and Event Patterns (path_to_url
// in the Amazon EventBridge User Guide.
EventPattern *string `type:"string"`
// If this is a managed rule, created by an Amazon Web Services service on your
// behalf, this field displays the principal name of the Amazon Web Services
// service that created the rule.
ManagedBy *string `min:"1" type:"string"`
// The name of the rule.
Name *string `min:"1" type:"string"`
// The Amazon Resource Name (ARN) of the IAM role associated with the rule.
RoleArn *string `min:"1" type:"string"`
// The scheduling expression. For example, "cron(0 20 * * ? *)", "rate(5 minutes)".
ScheduleExpression *string `type:"string"`
// Specifies whether the rule is enabled or disabled.
State *string `type:"string" enum:"RuleState"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeRuleOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DescribeRuleOutput) GoString() string {
return s.String()
}
// SetArn sets the Arn field's value.
func (s *DescribeRuleOutput) SetArn(v string) *DescribeRuleOutput {
s.Arn = &v
return s
}
// SetCreatedBy sets the CreatedBy field's value.
func (s *DescribeRuleOutput) SetCreatedBy(v string) *DescribeRuleOutput {
s.CreatedBy = &v
return s
}
// SetDescription sets the Description field's value.
func (s *DescribeRuleOutput) SetDescription(v string) *DescribeRuleOutput {
s.Description = &v
return s
}
// SetEventBusName sets the EventBusName field's value.
func (s *DescribeRuleOutput) SetEventBusName(v string) *DescribeRuleOutput {
s.EventBusName = &v
return s
}
// SetEventPattern sets the EventPattern field's value.
func (s *DescribeRuleOutput) SetEventPattern(v string) *DescribeRuleOutput {
s.EventPattern = &v
return s
}
// SetManagedBy sets the ManagedBy field's value.
func (s *DescribeRuleOutput) SetManagedBy(v string) *DescribeRuleOutput {
s.ManagedBy = &v
return s
}
// SetName sets the Name field's value.
func (s *DescribeRuleOutput) SetName(v string) *DescribeRuleOutput {
s.Name = &v
return s
}
// SetRoleArn sets the RoleArn field's value.
func (s *DescribeRuleOutput) SetRoleArn(v string) *DescribeRuleOutput {
s.RoleArn = &v
return s
}
// SetScheduleExpression sets the ScheduleExpression field's value.
func (s *DescribeRuleOutput) SetScheduleExpression(v string) *DescribeRuleOutput {
s.ScheduleExpression = &v
return s
}
// SetState sets the State field's value.
func (s *DescribeRuleOutput) SetState(v string) *DescribeRuleOutput {
s.State = &v
return s
}
type DisableRuleInput struct {
_ struct{} `type:"structure"`
// The name or ARN of the event bus associated with the rule. If you omit this,
// the default event bus is used.
EventBusName *string `min:"1" type:"string"`
// The name of the rule.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DisableRuleInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DisableRuleInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DisableRuleInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DisableRuleInput"}
if s.EventBusName != nil && len(*s.EventBusName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("EventBusName", 1))
}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetEventBusName sets the EventBusName field's value.
func (s *DisableRuleInput) SetEventBusName(v string) *DisableRuleInput {
s.EventBusName = &v
return s
}
// SetName sets the Name field's value.
func (s *DisableRuleInput) SetName(v string) *DisableRuleInput {
s.Name = &v
return s
}
type DisableRuleOutput struct {
_ struct{} `type:"structure"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DisableRuleOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s DisableRuleOutput) GoString() string {
return s.String()
}
// The custom parameters to be used when the target is an Amazon ECS task.
type EcsParameters struct {
_ struct{} `type:"structure"`
// The capacity provider strategy to use for the task.
//
// If a capacityProviderStrategy is specified, the launchType parameter must
// be omitted. If no capacityProviderStrategy or launchType is specified, the
// defaultCapacityProviderStrategy for the cluster is used.
CapacityProviderStrategy []*CapacityProviderStrategyItem `type:"list"`
// Specifies whether to enable Amazon ECS managed tags for the task. For more
// information, see Tagging Your Amazon ECS Resources (path_to_url
// in the Amazon Elastic Container Service Developer Guide.
EnableECSManagedTags *bool `type:"boolean"`
// Whether or not to enable the execute command functionality for the containers
// in this task. If true, this enables execute command functionality on all
// containers in the task.
EnableExecuteCommand *bool `type:"boolean"`
// Specifies an ECS task group for the task. The maximum length is 255 characters.
Group *string `type:"string"`
// Specifies the launch type on which your task is running. The launch type
// that you specify here must match one of the launch type (compatibilities)
// of the target task. The FARGATE value is supported only in the Regions where
// Fargate witt Amazon ECS is supported. For more information, see Fargate on
// Amazon ECS (path_to_url
// in the Amazon Elastic Container Service Developer Guide.
LaunchType *string `type:"string" enum:"LaunchType"`
// Use this structure if the Amazon ECS task uses the awsvpc network mode. This
// structure specifies the VPC subnets and security groups associated with the
// task, and whether a public IP address is to be used. This structure is required
// if LaunchType is FARGATE because the awsvpc mode is required for Fargate
// tasks.
//
// If you specify NetworkConfiguration when the target ECS task does not use
// the awsvpc network mode, the task fails.
NetworkConfiguration *NetworkConfiguration `type:"structure"`
// An array of placement constraint objects to use for the task. You can specify
// up to 10 constraints per task (including constraints in the task definition
// and those specified at runtime).
PlacementConstraints []*PlacementConstraint `type:"list"`
// The placement strategy objects to use for the task. You can specify a maximum
// of five strategy rules per task.
PlacementStrategy []*PlacementStrategy `type:"list"`
// Specifies the platform version for the task. Specify only the numeric portion
// of the platform version, such as 1.1.0.
//
// This structure is used only if LaunchType is FARGATE. For more information
// about valid platform versions, see Fargate Platform Versions (path_to_url
// in the Amazon Elastic Container Service Developer Guide.
PlatformVersion *string `type:"string"`
// Specifies whether to propagate the tags from the task definition to the task.
// If no value is specified, the tags are not propagated. Tags can only be propagated
// to the task during task creation. To add tags to a task after task creation,
// use the TagResource API action.
PropagateTags *string `type:"string" enum:"PropagateTags"`
// The reference ID to use for the task.
ReferenceId *string `type:"string"`
// The metadata that you apply to the task to help you categorize and organize
// them. Each tag consists of a key and an optional value, both of which you
// define. To learn more, see RunTask (path_to_url#ECS-RunTask-request-tags)
// in the Amazon ECS API Reference.
Tags []*Tag `type:"list"`
// The number of tasks to create based on TaskDefinition. The default is 1.
TaskCount *int64 `min:"1" type:"integer"`
// The ARN of the task definition to use if the event target is an Amazon ECS
// task.
//
// TaskDefinitionArn is a required field
TaskDefinitionArn *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s EcsParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s EcsParameters) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *EcsParameters) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "EcsParameters"}
if s.TaskCount != nil && *s.TaskCount < 1 {
invalidParams.Add(request.NewErrParamMinValue("TaskCount", 1))
}
if s.TaskDefinitionArn == nil {
invalidParams.Add(request.NewErrParamRequired("TaskDefinitionArn"))
}
if s.TaskDefinitionArn != nil && len(*s.TaskDefinitionArn) < 1 {
invalidParams.Add(request.NewErrParamMinLen("TaskDefinitionArn", 1))
}
if s.CapacityProviderStrategy != nil {
for i, v := range s.CapacityProviderStrategy {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "CapacityProviderStrategy", i), err.(request.ErrInvalidParams))
}
}
}
if s.NetworkConfiguration != nil {
if err := s.NetworkConfiguration.Validate(); err != nil {
invalidParams.AddNested("NetworkConfiguration", err.(request.ErrInvalidParams))
}
}
if s.Tags != nil {
for i, v := range s.Tags {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetCapacityProviderStrategy sets the CapacityProviderStrategy field's value.
func (s *EcsParameters) SetCapacityProviderStrategy(v []*CapacityProviderStrategyItem) *EcsParameters {
s.CapacityProviderStrategy = v
return s
}
// SetEnableECSManagedTags sets the EnableECSManagedTags field's value.
func (s *EcsParameters) SetEnableECSManagedTags(v bool) *EcsParameters {
s.EnableECSManagedTags = &v
return s
}
// SetEnableExecuteCommand sets the EnableExecuteCommand field's value.
func (s *EcsParameters) SetEnableExecuteCommand(v bool) *EcsParameters {
s.EnableExecuteCommand = &v
return s
}
// SetGroup sets the Group field's value.
func (s *EcsParameters) SetGroup(v string) *EcsParameters {
s.Group = &v
return s
}
// SetLaunchType sets the LaunchType field's value.
func (s *EcsParameters) SetLaunchType(v string) *EcsParameters {
s.LaunchType = &v
return s
}
// SetNetworkConfiguration sets the NetworkConfiguration field's value.
func (s *EcsParameters) SetNetworkConfiguration(v *NetworkConfiguration) *EcsParameters {
s.NetworkConfiguration = v
return s
}
// SetPlacementConstraints sets the PlacementConstraints field's value.
func (s *EcsParameters) SetPlacementConstraints(v []*PlacementConstraint) *EcsParameters {
s.PlacementConstraints = v
return s
}
// SetPlacementStrategy sets the PlacementStrategy field's value.
func (s *EcsParameters) SetPlacementStrategy(v []*PlacementStrategy) *EcsParameters {
s.PlacementStrategy = v
return s
}
// SetPlatformVersion sets the PlatformVersion field's value.
func (s *EcsParameters) SetPlatformVersion(v string) *EcsParameters {
s.PlatformVersion = &v
return s
}
// SetPropagateTags sets the PropagateTags field's value.
func (s *EcsParameters) SetPropagateTags(v string) *EcsParameters {
s.PropagateTags = &v
return s
}
// SetReferenceId sets the ReferenceId field's value.
func (s *EcsParameters) SetReferenceId(v string) *EcsParameters {
s.ReferenceId = &v
return s
}
// SetTags sets the Tags field's value.
func (s *EcsParameters) SetTags(v []*Tag) *EcsParameters {
s.Tags = v
return s
}
// SetTaskCount sets the TaskCount field's value.
func (s *EcsParameters) SetTaskCount(v int64) *EcsParameters {
s.TaskCount = &v
return s
}
// SetTaskDefinitionArn sets the TaskDefinitionArn field's value.
func (s *EcsParameters) SetTaskDefinitionArn(v string) *EcsParameters {
s.TaskDefinitionArn = &v
return s
}
type EnableRuleInput struct {
_ struct{} `type:"structure"`
// The name or ARN of the event bus associated with the rule. If you omit this,
// the default event bus is used.
EventBusName *string `min:"1" type:"string"`
// The name of the rule.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s EnableRuleInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s EnableRuleInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *EnableRuleInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "EnableRuleInput"}
if s.EventBusName != nil && len(*s.EventBusName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("EventBusName", 1))
}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetEventBusName sets the EventBusName field's value.
func (s *EnableRuleInput) SetEventBusName(v string) *EnableRuleInput {
s.EventBusName = &v
return s
}
// SetName sets the Name field's value.
func (s *EnableRuleInput) SetName(v string) *EnableRuleInput {
s.Name = &v
return s
}
type EnableRuleOutput struct {
_ struct{} `type:"structure"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s EnableRuleOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s EnableRuleOutput) GoString() string {
return s.String()
}
// An event bus receives events from a source and routes them to rules associated
// with that event bus. Your account's default event bus receives events from
// Amazon Web Services services. A custom event bus can receive events from
// your custom applications and services. A partner event bus receives events
// from an event source created by an SaaS partner. These events come from the
// partners services or applications.
type EventBus struct {
_ struct{} `type:"structure"`
// The ARN of the event bus.
Arn *string `type:"string"`
// The name of the event bus.
Name *string `type:"string"`
// The permissions policy of the event bus, describing which other Amazon Web
// Services accounts can write events to this event bus.
Policy *string `type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s EventBus) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s EventBus) GoString() string {
return s.String()
}
// SetArn sets the Arn field's value.
func (s *EventBus) SetArn(v string) *EventBus {
s.Arn = &v
return s
}
// SetName sets the Name field's value.
func (s *EventBus) SetName(v string) *EventBus {
s.Name = &v
return s
}
// SetPolicy sets the Policy field's value.
func (s *EventBus) SetPolicy(v string) *EventBus {
s.Policy = &v
return s
}
// A partner event source is created by an SaaS partner. If a customer creates
// a partner event bus that matches this event source, that Amazon Web Services
// account can receive events from the partner's applications or services.
type EventSource struct {
_ struct{} `type:"structure"`
// The ARN of the event source.
Arn *string `type:"string"`
// The name of the partner that created the event source.
CreatedBy *string `type:"string"`
// The date and time the event source was created.
CreationTime *time.Time `type:"timestamp"`
// The date and time that the event source will expire, if the Amazon Web Services
// account doesn't create a matching event bus for it.
ExpirationTime *time.Time `type:"timestamp"`
// The name of the event source.
Name *string `type:"string"`
// The state of the event source. If it is ACTIVE, you have already created
// a matching event bus for this event source, and that event bus is active.
// If it is PENDING, either you haven't yet created a matching event bus, or
// that event bus is deactivated. If it is DELETED, you have created a matching
// event bus, but the event source has since been deleted.
State *string `type:"string" enum:"EventSourceState"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s EventSource) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s EventSource) GoString() string {
return s.String()
}
// SetArn sets the Arn field's value.
func (s *EventSource) SetArn(v string) *EventSource {
s.Arn = &v
return s
}
// SetCreatedBy sets the CreatedBy field's value.
func (s *EventSource) SetCreatedBy(v string) *EventSource {
s.CreatedBy = &v
return s
}
// SetCreationTime sets the CreationTime field's value.
func (s *EventSource) SetCreationTime(v time.Time) *EventSource {
s.CreationTime = &v
return s
}
// SetExpirationTime sets the ExpirationTime field's value.
func (s *EventSource) SetExpirationTime(v time.Time) *EventSource {
s.ExpirationTime = &v
return s
}
// SetName sets the Name field's value.
func (s *EventSource) SetName(v string) *EventSource {
s.Name = &v
return s
}
// SetState sets the State field's value.
func (s *EventSource) SetState(v string) *EventSource {
s.State = &v
return s
}
// These are custom parameter to be used when the target is an API Gateway REST
// APIs or EventBridge ApiDestinations. In the latter case, these are merged
// with any InvocationParameters specified on the Connection, with any values
// from the Connection taking precedence.
type HttpParameters struct {
_ struct{} `type:"structure"`
// The headers that need to be sent as part of request invoking the API Gateway
// REST API or EventBridge ApiDestination.
HeaderParameters map[string]*string `type:"map"`
// The path parameter values to be used to populate API Gateway REST API or
// EventBridge ApiDestination path wildcards ("*").
PathParameterValues []*string `type:"list"`
// The query string keys/values that need to be sent as part of request invoking
// the API Gateway REST API or EventBridge ApiDestination.
QueryStringParameters map[string]*string `type:"map"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s HttpParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s HttpParameters) GoString() string {
return s.String()
}
// SetHeaderParameters sets the HeaderParameters field's value.
func (s *HttpParameters) SetHeaderParameters(v map[string]*string) *HttpParameters {
s.HeaderParameters = v
return s
}
// SetPathParameterValues sets the PathParameterValues field's value.
func (s *HttpParameters) SetPathParameterValues(v []*string) *HttpParameters {
s.PathParameterValues = v
return s
}
// SetQueryStringParameters sets the QueryStringParameters field's value.
func (s *HttpParameters) SetQueryStringParameters(v map[string]*string) *HttpParameters {
s.QueryStringParameters = v
return s
}
// An error occurred because a replay can be canceled only when the state is
// Running or Starting.
type IllegalStatusException struct {
_ struct{} `type:"structure"`
RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`
Message_ *string `locationName:"message" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s IllegalStatusException) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s IllegalStatusException) GoString() string {
return s.String()
}
func newErrorIllegalStatusException(v protocol.ResponseMetadata) error {
return &IllegalStatusException{
RespMetadata: v,
}
}
// Code returns the exception type name.
func (s *IllegalStatusException) Code() string {
return "IllegalStatusException"
}
// Message returns the exception's message.
func (s *IllegalStatusException) Message() string {
if s.Message_ != nil {
return *s.Message_
}
return ""
}
// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *IllegalStatusException) OrigErr() error {
return nil
}
func (s *IllegalStatusException) Error() string {
return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}
// Status code returns the HTTP status code for the request's response error.
func (s *IllegalStatusException) StatusCode() int {
return s.RespMetadata.StatusCode
}
// RequestID returns the service's response RequestID for request.
func (s *IllegalStatusException) RequestID() string {
return s.RespMetadata.RequestID
}
// Contains the parameters needed for you to provide custom input to a target
// based on one or more pieces of data extracted from the event.
type InputTransformer struct {
_ struct{} `type:"structure"`
// Map of JSON paths to be extracted from the event. You can then insert these
// in the template in InputTemplate to produce the output you want to be sent
// to the target.
//
// InputPathsMap is an array key-value pairs, where each value is a valid JSON
// path. You can have as many as 100 key-value pairs. You must use JSON dot
// notation, not bracket notation.
//
// The keys cannot start with "Amazon Web Services."
InputPathsMap map[string]*string `type:"map"`
// Input template where you specify placeholders that will be filled with the
// values of the keys from InputPathsMap to customize the data sent to the target.
// Enclose each InputPathsMaps value in brackets: <value> The InputTemplate
// must be valid JSON.
//
// If InputTemplate is a JSON object (surrounded by curly braces), the following
// restrictions apply:
//
// * The placeholder cannot be used as an object key.
//
// The following example shows the syntax for using InputPathsMap and InputTemplate.
//
// "InputTransformer":
//
// {
//
// "InputPathsMap": {"instance": "$.detail.instance","status": "$.detail.status"},
//
// "InputTemplate": "<instance> is in state <status>"
//
// }
//
// To have the InputTemplate include quote marks within a JSON string, escape
// each quote marks with a slash, as in the following example:
//
// "InputTransformer":
//
// {
//
// "InputPathsMap": {"instance": "$.detail.instance","status": "$.detail.status"},
//
// "InputTemplate": "<instance> is in state \"<status>\""
//
// }
//
// The InputTemplate can also be valid JSON with varibles in quotes or out,
// as in the following example:
//
// "InputTransformer":
//
// {
//
// "InputPathsMap": {"instance": "$.detail.instance","status": "$.detail.status"},
//
// "InputTemplate": '{"myInstance": <instance>,"myStatus": "<instance> is in
// state \"<status>\""}'
//
// }
//
// InputTemplate is a required field
InputTemplate *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s InputTransformer) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s InputTransformer) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *InputTransformer) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "InputTransformer"}
if s.InputTemplate == nil {
invalidParams.Add(request.NewErrParamRequired("InputTemplate"))
}
if s.InputTemplate != nil && len(*s.InputTemplate) < 1 {
invalidParams.Add(request.NewErrParamMinLen("InputTemplate", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetInputPathsMap sets the InputPathsMap field's value.
func (s *InputTransformer) SetInputPathsMap(v map[string]*string) *InputTransformer {
s.InputPathsMap = v
return s
}
// SetInputTemplate sets the InputTemplate field's value.
func (s *InputTransformer) SetInputTemplate(v string) *InputTransformer {
s.InputTemplate = &v
return s
}
// This exception occurs due to unexpected causes.
type InternalException struct {
_ struct{} `type:"structure"`
RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`
Message_ *string `locationName:"message" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s InternalException) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s InternalException) GoString() string {
return s.String()
}
func newErrorInternalException(v protocol.ResponseMetadata) error {
return &InternalException{
RespMetadata: v,
}
}
// Code returns the exception type name.
func (s *InternalException) Code() string {
return "InternalException"
}
// Message returns the exception's message.
func (s *InternalException) Message() string {
if s.Message_ != nil {
return *s.Message_
}
return ""
}
// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *InternalException) OrigErr() error {
return nil
}
func (s *InternalException) Error() string {
return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}
// Status code returns the HTTP status code for the request's response error.
func (s *InternalException) StatusCode() int {
return s.RespMetadata.StatusCode
}
// RequestID returns the service's response RequestID for request.
func (s *InternalException) RequestID() string {
return s.RespMetadata.RequestID
}
// The event pattern is not valid.
type InvalidEventPatternException struct {
_ struct{} `type:"structure"`
RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`
Message_ *string `locationName:"message" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s InvalidEventPatternException) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s InvalidEventPatternException) GoString() string {
return s.String()
}
func newErrorInvalidEventPatternException(v protocol.ResponseMetadata) error {
return &InvalidEventPatternException{
RespMetadata: v,
}
}
// Code returns the exception type name.
func (s *InvalidEventPatternException) Code() string {
return "InvalidEventPatternException"
}
// Message returns the exception's message.
func (s *InvalidEventPatternException) Message() string {
if s.Message_ != nil {
return *s.Message_
}
return ""
}
// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *InvalidEventPatternException) OrigErr() error {
return nil
}
func (s *InvalidEventPatternException) Error() string {
return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}
// Status code returns the HTTP status code for the request's response error.
func (s *InvalidEventPatternException) StatusCode() int {
return s.RespMetadata.StatusCode
}
// RequestID returns the service's response RequestID for request.
func (s *InvalidEventPatternException) RequestID() string {
return s.RespMetadata.RequestID
}
// The specified state is not a valid state for an event source.
type InvalidStateException struct {
_ struct{} `type:"structure"`
RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`
Message_ *string `locationName:"message" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s InvalidStateException) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s InvalidStateException) GoString() string {
return s.String()
}
func newErrorInvalidStateException(v protocol.ResponseMetadata) error {
return &InvalidStateException{
RespMetadata: v,
}
}
// Code returns the exception type name.
func (s *InvalidStateException) Code() string {
return "InvalidStateException"
}
// Message returns the exception's message.
func (s *InvalidStateException) Message() string {
if s.Message_ != nil {
return *s.Message_
}
return ""
}
// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *InvalidStateException) OrigErr() error {
return nil
}
func (s *InvalidStateException) Error() string {
return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}
// Status code returns the HTTP status code for the request's response error.
func (s *InvalidStateException) StatusCode() int {
return s.RespMetadata.StatusCode
}
// RequestID returns the service's response RequestID for request.
func (s *InvalidStateException) RequestID() string {
return s.RespMetadata.RequestID
}
// This object enables you to specify a JSON path to extract from the event
// and use as the partition key for the Amazon Kinesis data stream, so that
// you can control the shard to which the event goes. If you do not include
// this parameter, the default is to use the eventId as the partition key.
type KinesisParameters struct {
_ struct{} `type:"structure"`
// The JSON path to be extracted from the event and used as the partition key.
// For more information, see Amazon Kinesis Streams Key Concepts (path_to_url#partition-key)
// in the Amazon Kinesis Streams Developer Guide.
//
// PartitionKeyPath is a required field
PartitionKeyPath *string `type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s KinesisParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s KinesisParameters) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *KinesisParameters) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "KinesisParameters"}
if s.PartitionKeyPath == nil {
invalidParams.Add(request.NewErrParamRequired("PartitionKeyPath"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetPartitionKeyPath sets the PartitionKeyPath field's value.
func (s *KinesisParameters) SetPartitionKeyPath(v string) *KinesisParameters {
s.PartitionKeyPath = &v
return s
}
// The request failed because it attempted to create resource beyond the allowed
// service quota.
type LimitExceededException struct {
_ struct{} `type:"structure"`
RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`
Message_ *string `locationName:"message" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s LimitExceededException) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s LimitExceededException) GoString() string {
return s.String()
}
func newErrorLimitExceededException(v protocol.ResponseMetadata) error {
return &LimitExceededException{
RespMetadata: v,
}
}
// Code returns the exception type name.
func (s *LimitExceededException) Code() string {
return "LimitExceededException"
}
// Message returns the exception's message.
func (s *LimitExceededException) Message() string {
if s.Message_ != nil {
return *s.Message_
}
return ""
}
// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *LimitExceededException) OrigErr() error {
return nil
}
func (s *LimitExceededException) Error() string {
return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}
// Status code returns the HTTP status code for the request's response error.
func (s *LimitExceededException) StatusCode() int {
return s.RespMetadata.StatusCode
}
// RequestID returns the service's response RequestID for request.
func (s *LimitExceededException) RequestID() string {
return s.RespMetadata.RequestID
}
type ListApiDestinationsInput struct {
_ struct{} `type:"structure"`
// The ARN of the connection specified for the API destination.
ConnectionArn *string `min:"1" type:"string"`
// The maximum number of API destinations to include in the response.
Limit *int64 `min:"1" type:"integer"`
// A name prefix to filter results returned. Only API destinations with a name
// that starts with the prefix are returned.
NamePrefix *string `min:"1" type:"string"`
// The token returned by a previous call to retrieve the next set of results.
NextToken *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListApiDestinationsInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListApiDestinationsInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *ListApiDestinationsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "ListApiDestinationsInput"}
if s.ConnectionArn != nil && len(*s.ConnectionArn) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ConnectionArn", 1))
}
if s.Limit != nil && *s.Limit < 1 {
invalidParams.Add(request.NewErrParamMinValue("Limit", 1))
}
if s.NamePrefix != nil && len(*s.NamePrefix) < 1 {
invalidParams.Add(request.NewErrParamMinLen("NamePrefix", 1))
}
if s.NextToken != nil && len(*s.NextToken) < 1 {
invalidParams.Add(request.NewErrParamMinLen("NextToken", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetConnectionArn sets the ConnectionArn field's value.
func (s *ListApiDestinationsInput) SetConnectionArn(v string) *ListApiDestinationsInput {
s.ConnectionArn = &v
return s
}
// SetLimit sets the Limit field's value.
func (s *ListApiDestinationsInput) SetLimit(v int64) *ListApiDestinationsInput {
s.Limit = &v
return s
}
// SetNamePrefix sets the NamePrefix field's value.
func (s *ListApiDestinationsInput) SetNamePrefix(v string) *ListApiDestinationsInput {
s.NamePrefix = &v
return s
}
// SetNextToken sets the NextToken field's value.
func (s *ListApiDestinationsInput) SetNextToken(v string) *ListApiDestinationsInput {
s.NextToken = &v
return s
}
type ListApiDestinationsOutput struct {
_ struct{} `type:"structure"`
// An array of ApiDestination objects that include information about an API
// destination.
ApiDestinations []*ApiDestination `type:"list"`
// A token you can use in a subsequent request to retrieve the next set of results.
NextToken *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListApiDestinationsOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListApiDestinationsOutput) GoString() string {
return s.String()
}
// SetApiDestinations sets the ApiDestinations field's value.
func (s *ListApiDestinationsOutput) SetApiDestinations(v []*ApiDestination) *ListApiDestinationsOutput {
s.ApiDestinations = v
return s
}
// SetNextToken sets the NextToken field's value.
func (s *ListApiDestinationsOutput) SetNextToken(v string) *ListApiDestinationsOutput {
s.NextToken = &v
return s
}
type ListArchivesInput struct {
_ struct{} `type:"structure"`
// The ARN of the event source associated with the archive.
EventSourceArn *string `min:"1" type:"string"`
// The maximum number of results to return.
Limit *int64 `min:"1" type:"integer"`
// A name prefix to filter the archives returned. Only archives with name that
// match the prefix are returned.
NamePrefix *string `min:"1" type:"string"`
// The token returned by a previous call to retrieve the next set of results.
NextToken *string `min:"1" type:"string"`
// The state of the archive.
State *string `type:"string" enum:"ArchiveState"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListArchivesInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListArchivesInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *ListArchivesInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "ListArchivesInput"}
if s.EventSourceArn != nil && len(*s.EventSourceArn) < 1 {
invalidParams.Add(request.NewErrParamMinLen("EventSourceArn", 1))
}
if s.Limit != nil && *s.Limit < 1 {
invalidParams.Add(request.NewErrParamMinValue("Limit", 1))
}
if s.NamePrefix != nil && len(*s.NamePrefix) < 1 {
invalidParams.Add(request.NewErrParamMinLen("NamePrefix", 1))
}
if s.NextToken != nil && len(*s.NextToken) < 1 {
invalidParams.Add(request.NewErrParamMinLen("NextToken", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetEventSourceArn sets the EventSourceArn field's value.
func (s *ListArchivesInput) SetEventSourceArn(v string) *ListArchivesInput {
s.EventSourceArn = &v
return s
}
// SetLimit sets the Limit field's value.
func (s *ListArchivesInput) SetLimit(v int64) *ListArchivesInput {
s.Limit = &v
return s
}
// SetNamePrefix sets the NamePrefix field's value.
func (s *ListArchivesInput) SetNamePrefix(v string) *ListArchivesInput {
s.NamePrefix = &v
return s
}
// SetNextToken sets the NextToken field's value.
func (s *ListArchivesInput) SetNextToken(v string) *ListArchivesInput {
s.NextToken = &v
return s
}
// SetState sets the State field's value.
func (s *ListArchivesInput) SetState(v string) *ListArchivesInput {
s.State = &v
return s
}
type ListArchivesOutput struct {
_ struct{} `type:"structure"`
// An array of Archive objects that include details about an archive.
Archives []*Archive `type:"list"`
// The token returned by a previous call to retrieve the next set of results.
NextToken *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListArchivesOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListArchivesOutput) GoString() string {
return s.String()
}
// SetArchives sets the Archives field's value.
func (s *ListArchivesOutput) SetArchives(v []*Archive) *ListArchivesOutput {
s.Archives = v
return s
}
// SetNextToken sets the NextToken field's value.
func (s *ListArchivesOutput) SetNextToken(v string) *ListArchivesOutput {
s.NextToken = &v
return s
}
type ListConnectionsInput struct {
_ struct{} `type:"structure"`
// The state of the connection.
ConnectionState *string `type:"string" enum:"ConnectionState"`
// The maximum number of connections to return.
Limit *int64 `min:"1" type:"integer"`
// A name prefix to filter results returned. Only connections with a name that
// starts with the prefix are returned.
NamePrefix *string `min:"1" type:"string"`
// The token returned by a previous call to retrieve the next set of results.
NextToken *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListConnectionsInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListConnectionsInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *ListConnectionsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "ListConnectionsInput"}
if s.Limit != nil && *s.Limit < 1 {
invalidParams.Add(request.NewErrParamMinValue("Limit", 1))
}
if s.NamePrefix != nil && len(*s.NamePrefix) < 1 {
invalidParams.Add(request.NewErrParamMinLen("NamePrefix", 1))
}
if s.NextToken != nil && len(*s.NextToken) < 1 {
invalidParams.Add(request.NewErrParamMinLen("NextToken", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetConnectionState sets the ConnectionState field's value.
func (s *ListConnectionsInput) SetConnectionState(v string) *ListConnectionsInput {
s.ConnectionState = &v
return s
}
// SetLimit sets the Limit field's value.
func (s *ListConnectionsInput) SetLimit(v int64) *ListConnectionsInput {
s.Limit = &v
return s
}
// SetNamePrefix sets the NamePrefix field's value.
func (s *ListConnectionsInput) SetNamePrefix(v string) *ListConnectionsInput {
s.NamePrefix = &v
return s
}
// SetNextToken sets the NextToken field's value.
func (s *ListConnectionsInput) SetNextToken(v string) *ListConnectionsInput {
s.NextToken = &v
return s
}
type ListConnectionsOutput struct {
_ struct{} `type:"structure"`
// An array of connections objects that include details about the connections.
Connections []*Connection `type:"list"`
// A token you can use in a subsequent request to retrieve the next set of results.
NextToken *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListConnectionsOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListConnectionsOutput) GoString() string {
return s.String()
}
// SetConnections sets the Connections field's value.
func (s *ListConnectionsOutput) SetConnections(v []*Connection) *ListConnectionsOutput {
s.Connections = v
return s
}
// SetNextToken sets the NextToken field's value.
func (s *ListConnectionsOutput) SetNextToken(v string) *ListConnectionsOutput {
s.NextToken = &v
return s
}
type ListEventBusesInput struct {
_ struct{} `type:"structure"`
// Specifying this limits the number of results returned by this operation.
// The operation also returns a NextToken which you can use in a subsequent
// operation to retrieve the next set of results.
Limit *int64 `min:"1" type:"integer"`
// Specifying this limits the results to only those event buses with names that
// start with the specified prefix.
NamePrefix *string `min:"1" type:"string"`
// The token returned by a previous call to retrieve the next set of results.
NextToken *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListEventBusesInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListEventBusesInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *ListEventBusesInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "ListEventBusesInput"}
if s.Limit != nil && *s.Limit < 1 {
invalidParams.Add(request.NewErrParamMinValue("Limit", 1))
}
if s.NamePrefix != nil && len(*s.NamePrefix) < 1 {
invalidParams.Add(request.NewErrParamMinLen("NamePrefix", 1))
}
if s.NextToken != nil && len(*s.NextToken) < 1 {
invalidParams.Add(request.NewErrParamMinLen("NextToken", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetLimit sets the Limit field's value.
func (s *ListEventBusesInput) SetLimit(v int64) *ListEventBusesInput {
s.Limit = &v
return s
}
// SetNamePrefix sets the NamePrefix field's value.
func (s *ListEventBusesInput) SetNamePrefix(v string) *ListEventBusesInput {
s.NamePrefix = &v
return s
}
// SetNextToken sets the NextToken field's value.
func (s *ListEventBusesInput) SetNextToken(v string) *ListEventBusesInput {
s.NextToken = &v
return s
}
type ListEventBusesOutput struct {
_ struct{} `type:"structure"`
// This list of event buses.
EventBuses []*EventBus `type:"list"`
// A token you can use in a subsequent operation to retrieve the next set of
// results.
NextToken *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListEventBusesOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListEventBusesOutput) GoString() string {
return s.String()
}
// SetEventBuses sets the EventBuses field's value.
func (s *ListEventBusesOutput) SetEventBuses(v []*EventBus) *ListEventBusesOutput {
s.EventBuses = v
return s
}
// SetNextToken sets the NextToken field's value.
func (s *ListEventBusesOutput) SetNextToken(v string) *ListEventBusesOutput {
s.NextToken = &v
return s
}
type ListEventSourcesInput struct {
_ struct{} `type:"structure"`
// Specifying this limits the number of results returned by this operation.
// The operation also returns a NextToken which you can use in a subsequent
// operation to retrieve the next set of results.
Limit *int64 `min:"1" type:"integer"`
// Specifying this limits the results to only those partner event sources with
// names that start with the specified prefix.
NamePrefix *string `min:"1" type:"string"`
// The token returned by a previous call to retrieve the next set of results.
NextToken *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListEventSourcesInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListEventSourcesInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *ListEventSourcesInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "ListEventSourcesInput"}
if s.Limit != nil && *s.Limit < 1 {
invalidParams.Add(request.NewErrParamMinValue("Limit", 1))
}
if s.NamePrefix != nil && len(*s.NamePrefix) < 1 {
invalidParams.Add(request.NewErrParamMinLen("NamePrefix", 1))
}
if s.NextToken != nil && len(*s.NextToken) < 1 {
invalidParams.Add(request.NewErrParamMinLen("NextToken", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetLimit sets the Limit field's value.
func (s *ListEventSourcesInput) SetLimit(v int64) *ListEventSourcesInput {
s.Limit = &v
return s
}
// SetNamePrefix sets the NamePrefix field's value.
func (s *ListEventSourcesInput) SetNamePrefix(v string) *ListEventSourcesInput {
s.NamePrefix = &v
return s
}
// SetNextToken sets the NextToken field's value.
func (s *ListEventSourcesInput) SetNextToken(v string) *ListEventSourcesInput {
s.NextToken = &v
return s
}
type ListEventSourcesOutput struct {
_ struct{} `type:"structure"`
// The list of event sources.
EventSources []*EventSource `type:"list"`
// A token you can use in a subsequent operation to retrieve the next set of
// results.
NextToken *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListEventSourcesOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListEventSourcesOutput) GoString() string {
return s.String()
}
// SetEventSources sets the EventSources field's value.
func (s *ListEventSourcesOutput) SetEventSources(v []*EventSource) *ListEventSourcesOutput {
s.EventSources = v
return s
}
// SetNextToken sets the NextToken field's value.
func (s *ListEventSourcesOutput) SetNextToken(v string) *ListEventSourcesOutput {
s.NextToken = &v
return s
}
type ListPartnerEventSourceAccountsInput struct {
_ struct{} `type:"structure"`
// The name of the partner event source to display account information about.
//
// EventSourceName is a required field
EventSourceName *string `min:"1" type:"string" required:"true"`
// Specifying this limits the number of results returned by this operation.
// The operation also returns a NextToken which you can use in a subsequent
// operation to retrieve the next set of results.
Limit *int64 `min:"1" type:"integer"`
// The token returned by a previous call to this operation. Specifying this
// retrieves the next set of results.
NextToken *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListPartnerEventSourceAccountsInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListPartnerEventSourceAccountsInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *ListPartnerEventSourceAccountsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "ListPartnerEventSourceAccountsInput"}
if s.EventSourceName == nil {
invalidParams.Add(request.NewErrParamRequired("EventSourceName"))
}
if s.EventSourceName != nil && len(*s.EventSourceName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("EventSourceName", 1))
}
if s.Limit != nil && *s.Limit < 1 {
invalidParams.Add(request.NewErrParamMinValue("Limit", 1))
}
if s.NextToken != nil && len(*s.NextToken) < 1 {
invalidParams.Add(request.NewErrParamMinLen("NextToken", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetEventSourceName sets the EventSourceName field's value.
func (s *ListPartnerEventSourceAccountsInput) SetEventSourceName(v string) *ListPartnerEventSourceAccountsInput {
s.EventSourceName = &v
return s
}
// SetLimit sets the Limit field's value.
func (s *ListPartnerEventSourceAccountsInput) SetLimit(v int64) *ListPartnerEventSourceAccountsInput {
s.Limit = &v
return s
}
// SetNextToken sets the NextToken field's value.
func (s *ListPartnerEventSourceAccountsInput) SetNextToken(v string) *ListPartnerEventSourceAccountsInput {
s.NextToken = &v
return s
}
type ListPartnerEventSourceAccountsOutput struct {
_ struct{} `type:"structure"`
// A token you can use in a subsequent operation to retrieve the next set of
// results.
NextToken *string `min:"1" type:"string"`
// The list of partner event sources returned by the operation.
PartnerEventSourceAccounts []*PartnerEventSourceAccount `type:"list"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListPartnerEventSourceAccountsOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListPartnerEventSourceAccountsOutput) GoString() string {
return s.String()
}
// SetNextToken sets the NextToken field's value.
func (s *ListPartnerEventSourceAccountsOutput) SetNextToken(v string) *ListPartnerEventSourceAccountsOutput {
s.NextToken = &v
return s
}
// SetPartnerEventSourceAccounts sets the PartnerEventSourceAccounts field's value.
func (s *ListPartnerEventSourceAccountsOutput) SetPartnerEventSourceAccounts(v []*PartnerEventSourceAccount) *ListPartnerEventSourceAccountsOutput {
s.PartnerEventSourceAccounts = v
return s
}
type ListPartnerEventSourcesInput struct {
_ struct{} `type:"structure"`
// pecifying this limits the number of results returned by this operation. The
// operation also returns a NextToken which you can use in a subsequent operation
// to retrieve the next set of results.
Limit *int64 `min:"1" type:"integer"`
// If you specify this, the results are limited to only those partner event
// sources that start with the string you specify.
//
// NamePrefix is a required field
NamePrefix *string `min:"1" type:"string" required:"true"`
// The token returned by a previous call to this operation. Specifying this
// retrieves the next set of results.
NextToken *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListPartnerEventSourcesInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListPartnerEventSourcesInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *ListPartnerEventSourcesInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "ListPartnerEventSourcesInput"}
if s.Limit != nil && *s.Limit < 1 {
invalidParams.Add(request.NewErrParamMinValue("Limit", 1))
}
if s.NamePrefix == nil {
invalidParams.Add(request.NewErrParamRequired("NamePrefix"))
}
if s.NamePrefix != nil && len(*s.NamePrefix) < 1 {
invalidParams.Add(request.NewErrParamMinLen("NamePrefix", 1))
}
if s.NextToken != nil && len(*s.NextToken) < 1 {
invalidParams.Add(request.NewErrParamMinLen("NextToken", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetLimit sets the Limit field's value.
func (s *ListPartnerEventSourcesInput) SetLimit(v int64) *ListPartnerEventSourcesInput {
s.Limit = &v
return s
}
// SetNamePrefix sets the NamePrefix field's value.
func (s *ListPartnerEventSourcesInput) SetNamePrefix(v string) *ListPartnerEventSourcesInput {
s.NamePrefix = &v
return s
}
// SetNextToken sets the NextToken field's value.
func (s *ListPartnerEventSourcesInput) SetNextToken(v string) *ListPartnerEventSourcesInput {
s.NextToken = &v
return s
}
type ListPartnerEventSourcesOutput struct {
_ struct{} `type:"structure"`
// A token you can use in a subsequent operation to retrieve the next set of
// results.
NextToken *string `min:"1" type:"string"`
// The list of partner event sources returned by the operation.
PartnerEventSources []*PartnerEventSource `type:"list"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListPartnerEventSourcesOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListPartnerEventSourcesOutput) GoString() string {
return s.String()
}
// SetNextToken sets the NextToken field's value.
func (s *ListPartnerEventSourcesOutput) SetNextToken(v string) *ListPartnerEventSourcesOutput {
s.NextToken = &v
return s
}
// SetPartnerEventSources sets the PartnerEventSources field's value.
func (s *ListPartnerEventSourcesOutput) SetPartnerEventSources(v []*PartnerEventSource) *ListPartnerEventSourcesOutput {
s.PartnerEventSources = v
return s
}
type ListReplaysInput struct {
_ struct{} `type:"structure"`
// The ARN of the archive from which the events are replayed.
EventSourceArn *string `min:"1" type:"string"`
// The maximum number of replays to retrieve.
Limit *int64 `min:"1" type:"integer"`
// A name prefix to filter the replays returned. Only replays with name that
// match the prefix are returned.
NamePrefix *string `min:"1" type:"string"`
// The token returned by a previous call to retrieve the next set of results.
NextToken *string `min:"1" type:"string"`
// The state of the replay.
State *string `type:"string" enum:"ReplayState"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListReplaysInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListReplaysInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *ListReplaysInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "ListReplaysInput"}
if s.EventSourceArn != nil && len(*s.EventSourceArn) < 1 {
invalidParams.Add(request.NewErrParamMinLen("EventSourceArn", 1))
}
if s.Limit != nil && *s.Limit < 1 {
invalidParams.Add(request.NewErrParamMinValue("Limit", 1))
}
if s.NamePrefix != nil && len(*s.NamePrefix) < 1 {
invalidParams.Add(request.NewErrParamMinLen("NamePrefix", 1))
}
if s.NextToken != nil && len(*s.NextToken) < 1 {
invalidParams.Add(request.NewErrParamMinLen("NextToken", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetEventSourceArn sets the EventSourceArn field's value.
func (s *ListReplaysInput) SetEventSourceArn(v string) *ListReplaysInput {
s.EventSourceArn = &v
return s
}
// SetLimit sets the Limit field's value.
func (s *ListReplaysInput) SetLimit(v int64) *ListReplaysInput {
s.Limit = &v
return s
}
// SetNamePrefix sets the NamePrefix field's value.
func (s *ListReplaysInput) SetNamePrefix(v string) *ListReplaysInput {
s.NamePrefix = &v
return s
}
// SetNextToken sets the NextToken field's value.
func (s *ListReplaysInput) SetNextToken(v string) *ListReplaysInput {
s.NextToken = &v
return s
}
// SetState sets the State field's value.
func (s *ListReplaysInput) SetState(v string) *ListReplaysInput {
s.State = &v
return s
}
type ListReplaysOutput struct {
_ struct{} `type:"structure"`
// The token returned by a previous call to retrieve the next set of results.
NextToken *string `min:"1" type:"string"`
// An array of Replay objects that contain information about the replay.
Replays []*Replay `type:"list"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListReplaysOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListReplaysOutput) GoString() string {
return s.String()
}
// SetNextToken sets the NextToken field's value.
func (s *ListReplaysOutput) SetNextToken(v string) *ListReplaysOutput {
s.NextToken = &v
return s
}
// SetReplays sets the Replays field's value.
func (s *ListReplaysOutput) SetReplays(v []*Replay) *ListReplaysOutput {
s.Replays = v
return s
}
type ListRuleNamesByTargetInput struct {
_ struct{} `type:"structure"`
// The name or ARN of the event bus to list rules for. If you omit this, the
// default event bus is used.
EventBusName *string `min:"1" type:"string"`
// The maximum number of results to return.
Limit *int64 `min:"1" type:"integer"`
// The token returned by a previous call to retrieve the next set of results.
NextToken *string `min:"1" type:"string"`
// The Amazon Resource Name (ARN) of the target resource.
//
// TargetArn is a required field
TargetArn *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListRuleNamesByTargetInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListRuleNamesByTargetInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *ListRuleNamesByTargetInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "ListRuleNamesByTargetInput"}
if s.EventBusName != nil && len(*s.EventBusName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("EventBusName", 1))
}
if s.Limit != nil && *s.Limit < 1 {
invalidParams.Add(request.NewErrParamMinValue("Limit", 1))
}
if s.NextToken != nil && len(*s.NextToken) < 1 {
invalidParams.Add(request.NewErrParamMinLen("NextToken", 1))
}
if s.TargetArn == nil {
invalidParams.Add(request.NewErrParamRequired("TargetArn"))
}
if s.TargetArn != nil && len(*s.TargetArn) < 1 {
invalidParams.Add(request.NewErrParamMinLen("TargetArn", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetEventBusName sets the EventBusName field's value.
func (s *ListRuleNamesByTargetInput) SetEventBusName(v string) *ListRuleNamesByTargetInput {
s.EventBusName = &v
return s
}
// SetLimit sets the Limit field's value.
func (s *ListRuleNamesByTargetInput) SetLimit(v int64) *ListRuleNamesByTargetInput {
s.Limit = &v
return s
}
// SetNextToken sets the NextToken field's value.
func (s *ListRuleNamesByTargetInput) SetNextToken(v string) *ListRuleNamesByTargetInput {
s.NextToken = &v
return s
}
// SetTargetArn sets the TargetArn field's value.
func (s *ListRuleNamesByTargetInput) SetTargetArn(v string) *ListRuleNamesByTargetInput {
s.TargetArn = &v
return s
}
type ListRuleNamesByTargetOutput struct {
_ struct{} `type:"structure"`
// Indicates whether there are additional results to retrieve. If there are
// no more results, the value is null.
NextToken *string `min:"1" type:"string"`
// The names of the rules that can invoke the given target.
RuleNames []*string `type:"list"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListRuleNamesByTargetOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListRuleNamesByTargetOutput) GoString() string {
return s.String()
}
// SetNextToken sets the NextToken field's value.
func (s *ListRuleNamesByTargetOutput) SetNextToken(v string) *ListRuleNamesByTargetOutput {
s.NextToken = &v
return s
}
// SetRuleNames sets the RuleNames field's value.
func (s *ListRuleNamesByTargetOutput) SetRuleNames(v []*string) *ListRuleNamesByTargetOutput {
s.RuleNames = v
return s
}
type ListRulesInput struct {
_ struct{} `type:"structure"`
// The name or ARN of the event bus to list the rules for. If you omit this,
// the default event bus is used.
EventBusName *string `min:"1" type:"string"`
// The maximum number of results to return.
Limit *int64 `min:"1" type:"integer"`
// The prefix matching the rule name.
NamePrefix *string `min:"1" type:"string"`
// The token returned by a previous call to retrieve the next set of results.
NextToken *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListRulesInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListRulesInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *ListRulesInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "ListRulesInput"}
if s.EventBusName != nil && len(*s.EventBusName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("EventBusName", 1))
}
if s.Limit != nil && *s.Limit < 1 {
invalidParams.Add(request.NewErrParamMinValue("Limit", 1))
}
if s.NamePrefix != nil && len(*s.NamePrefix) < 1 {
invalidParams.Add(request.NewErrParamMinLen("NamePrefix", 1))
}
if s.NextToken != nil && len(*s.NextToken) < 1 {
invalidParams.Add(request.NewErrParamMinLen("NextToken", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetEventBusName sets the EventBusName field's value.
func (s *ListRulesInput) SetEventBusName(v string) *ListRulesInput {
s.EventBusName = &v
return s
}
// SetLimit sets the Limit field's value.
func (s *ListRulesInput) SetLimit(v int64) *ListRulesInput {
s.Limit = &v
return s
}
// SetNamePrefix sets the NamePrefix field's value.
func (s *ListRulesInput) SetNamePrefix(v string) *ListRulesInput {
s.NamePrefix = &v
return s
}
// SetNextToken sets the NextToken field's value.
func (s *ListRulesInput) SetNextToken(v string) *ListRulesInput {
s.NextToken = &v
return s
}
type ListRulesOutput struct {
_ struct{} `type:"structure"`
// Indicates whether there are additional results to retrieve. If there are
// no more results, the value is null.
NextToken *string `min:"1" type:"string"`
// The rules that match the specified criteria.
Rules []*Rule `type:"list"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListRulesOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListRulesOutput) GoString() string {
return s.String()
}
// SetNextToken sets the NextToken field's value.
func (s *ListRulesOutput) SetNextToken(v string) *ListRulesOutput {
s.NextToken = &v
return s
}
// SetRules sets the Rules field's value.
func (s *ListRulesOutput) SetRules(v []*Rule) *ListRulesOutput {
s.Rules = v
return s
}
type ListTagsForResourceInput struct {
_ struct{} `type:"structure"`
// The ARN of the EventBridge resource for which you want to view tags.
//
// ResourceARN is a required field
ResourceARN *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListTagsForResourceInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListTagsForResourceInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *ListTagsForResourceInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "ListTagsForResourceInput"}
if s.ResourceARN == nil {
invalidParams.Add(request.NewErrParamRequired("ResourceARN"))
}
if s.ResourceARN != nil && len(*s.ResourceARN) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ResourceARN", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetResourceARN sets the ResourceARN field's value.
func (s *ListTagsForResourceInput) SetResourceARN(v string) *ListTagsForResourceInput {
s.ResourceARN = &v
return s
}
type ListTagsForResourceOutput struct {
_ struct{} `type:"structure"`
// The list of tag keys and values associated with the resource you specified
Tags []*Tag `type:"list"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListTagsForResourceOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListTagsForResourceOutput) GoString() string {
return s.String()
}
// SetTags sets the Tags field's value.
func (s *ListTagsForResourceOutput) SetTags(v []*Tag) *ListTagsForResourceOutput {
s.Tags = v
return s
}
type ListTargetsByRuleInput struct {
_ struct{} `type:"structure"`
// The name or ARN of the event bus associated with the rule. If you omit this,
// the default event bus is used.
EventBusName *string `min:"1" type:"string"`
// The maximum number of results to return.
Limit *int64 `min:"1" type:"integer"`
// The token returned by a previous call to retrieve the next set of results.
NextToken *string `min:"1" type:"string"`
// The name of the rule.
//
// Rule is a required field
Rule *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListTargetsByRuleInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListTargetsByRuleInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *ListTargetsByRuleInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "ListTargetsByRuleInput"}
if s.EventBusName != nil && len(*s.EventBusName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("EventBusName", 1))
}
if s.Limit != nil && *s.Limit < 1 {
invalidParams.Add(request.NewErrParamMinValue("Limit", 1))
}
if s.NextToken != nil && len(*s.NextToken) < 1 {
invalidParams.Add(request.NewErrParamMinLen("NextToken", 1))
}
if s.Rule == nil {
invalidParams.Add(request.NewErrParamRequired("Rule"))
}
if s.Rule != nil && len(*s.Rule) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Rule", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetEventBusName sets the EventBusName field's value.
func (s *ListTargetsByRuleInput) SetEventBusName(v string) *ListTargetsByRuleInput {
s.EventBusName = &v
return s
}
// SetLimit sets the Limit field's value.
func (s *ListTargetsByRuleInput) SetLimit(v int64) *ListTargetsByRuleInput {
s.Limit = &v
return s
}
// SetNextToken sets the NextToken field's value.
func (s *ListTargetsByRuleInput) SetNextToken(v string) *ListTargetsByRuleInput {
s.NextToken = &v
return s
}
// SetRule sets the Rule field's value.
func (s *ListTargetsByRuleInput) SetRule(v string) *ListTargetsByRuleInput {
s.Rule = &v
return s
}
type ListTargetsByRuleOutput struct {
_ struct{} `type:"structure"`
// Indicates whether there are additional results to retrieve. If there are
// no more results, the value is null.
NextToken *string `min:"1" type:"string"`
// The targets assigned to the rule.
Targets []*Target `min:"1" type:"list"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListTargetsByRuleOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ListTargetsByRuleOutput) GoString() string {
return s.String()
}
// SetNextToken sets the NextToken field's value.
func (s *ListTargetsByRuleOutput) SetNextToken(v string) *ListTargetsByRuleOutput {
s.NextToken = &v
return s
}
// SetTargets sets the Targets field's value.
func (s *ListTargetsByRuleOutput) SetTargets(v []*Target) *ListTargetsByRuleOutput {
s.Targets = v
return s
}
// This rule was created by an Amazon Web Services service on behalf of your
// account. It is managed by that service. If you see this error in response
// to DeleteRule or RemoveTargets, you can use the Force parameter in those
// calls to delete the rule or remove targets from the rule. You cannot modify
// these managed rules by using DisableRule, EnableRule, PutTargets, PutRule,
// TagResource, or UntagResource.
type ManagedRuleException struct {
_ struct{} `type:"structure"`
RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`
Message_ *string `locationName:"message" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ManagedRuleException) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ManagedRuleException) GoString() string {
return s.String()
}
func newErrorManagedRuleException(v protocol.ResponseMetadata) error {
return &ManagedRuleException{
RespMetadata: v,
}
}
// Code returns the exception type name.
func (s *ManagedRuleException) Code() string {
return "ManagedRuleException"
}
// Message returns the exception's message.
func (s *ManagedRuleException) Message() string {
if s.Message_ != nil {
return *s.Message_
}
return ""
}
// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *ManagedRuleException) OrigErr() error {
return nil
}
func (s *ManagedRuleException) Error() string {
return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}
// Status code returns the HTTP status code for the request's response error.
func (s *ManagedRuleException) StatusCode() int {
return s.RespMetadata.StatusCode
}
// RequestID returns the service's response RequestID for request.
func (s *ManagedRuleException) RequestID() string {
return s.RespMetadata.RequestID
}
// This structure specifies the network configuration for an ECS task.
type NetworkConfiguration struct {
_ struct{} `type:"structure"`
// Use this structure to specify the VPC subnets and security groups for the
// task, and whether a public IP address is to be used. This structure is relevant
// only for ECS tasks that use the awsvpc network mode.
AwsvpcConfiguration *AwsVpcConfiguration `locationName:"awsvpcConfiguration" type:"structure"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s NetworkConfiguration) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s NetworkConfiguration) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *NetworkConfiguration) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "NetworkConfiguration"}
if s.AwsvpcConfiguration != nil {
if err := s.AwsvpcConfiguration.Validate(); err != nil {
invalidParams.AddNested("AwsvpcConfiguration", err.(request.ErrInvalidParams))
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetAwsvpcConfiguration sets the AwsvpcConfiguration field's value.
func (s *NetworkConfiguration) SetAwsvpcConfiguration(v *AwsVpcConfiguration) *NetworkConfiguration {
s.AwsvpcConfiguration = v
return s
}
// The operation you are attempting is not available in this region.
type OperationDisabledException struct {
_ struct{} `type:"structure"`
RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`
Message_ *string `locationName:"message" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s OperationDisabledException) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s OperationDisabledException) GoString() string {
return s.String()
}
func newErrorOperationDisabledException(v protocol.ResponseMetadata) error {
return &OperationDisabledException{
RespMetadata: v,
}
}
// Code returns the exception type name.
func (s *OperationDisabledException) Code() string {
return "OperationDisabledException"
}
// Message returns the exception's message.
func (s *OperationDisabledException) Message() string {
if s.Message_ != nil {
return *s.Message_
}
return ""
}
// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *OperationDisabledException) OrigErr() error {
return nil
}
func (s *OperationDisabledException) Error() string {
return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}
// Status code returns the HTTP status code for the request's response error.
func (s *OperationDisabledException) StatusCode() int {
return s.RespMetadata.StatusCode
}
// RequestID returns the service's response RequestID for request.
func (s *OperationDisabledException) RequestID() string {
return s.RespMetadata.RequestID
}
// A partner event source is created by an SaaS partner. If a customer creates
// a partner event bus that matches this event source, that Amazon Web Services
// account can receive events from the partner's applications or services.
type PartnerEventSource struct {
_ struct{} `type:"structure"`
// The ARN of the partner event source.
Arn *string `type:"string"`
// The name of the partner event source.
Name *string `type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PartnerEventSource) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PartnerEventSource) GoString() string {
return s.String()
}
// SetArn sets the Arn field's value.
func (s *PartnerEventSource) SetArn(v string) *PartnerEventSource {
s.Arn = &v
return s
}
// SetName sets the Name field's value.
func (s *PartnerEventSource) SetName(v string) *PartnerEventSource {
s.Name = &v
return s
}
// The Amazon Web Services account that a partner event source has been offered
// to.
type PartnerEventSourceAccount struct {
_ struct{} `type:"structure"`
// The Amazon Web Services account ID that the partner event source was offered
// to.
Account *string `min:"12" type:"string"`
// The date and time the event source was created.
CreationTime *time.Time `type:"timestamp"`
// The date and time that the event source will expire, if the Amazon Web Services
// account doesn't create a matching event bus for it.
ExpirationTime *time.Time `type:"timestamp"`
// The state of the event source. If it is ACTIVE, you have already created
// a matching event bus for this event source, and that event bus is active.
// If it is PENDING, either you haven't yet created a matching event bus, or
// that event bus is deactivated. If it is DELETED, you have created a matching
// event bus, but the event source has since been deleted.
State *string `type:"string" enum:"EventSourceState"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PartnerEventSourceAccount) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PartnerEventSourceAccount) GoString() string {
return s.String()
}
// SetAccount sets the Account field's value.
func (s *PartnerEventSourceAccount) SetAccount(v string) *PartnerEventSourceAccount {
s.Account = &v
return s
}
// SetCreationTime sets the CreationTime field's value.
func (s *PartnerEventSourceAccount) SetCreationTime(v time.Time) *PartnerEventSourceAccount {
s.CreationTime = &v
return s
}
// SetExpirationTime sets the ExpirationTime field's value.
func (s *PartnerEventSourceAccount) SetExpirationTime(v time.Time) *PartnerEventSourceAccount {
s.ExpirationTime = &v
return s
}
// SetState sets the State field's value.
func (s *PartnerEventSourceAccount) SetState(v string) *PartnerEventSourceAccount {
s.State = &v
return s
}
// An object representing a constraint on task placement. To learn more, see
// Task Placement Constraints (path_to_url
// in the Amazon Elastic Container Service Developer Guide.
type PlacementConstraint struct {
_ struct{} `type:"structure"`
// A cluster query language expression to apply to the constraint. You cannot
// specify an expression if the constraint type is distinctInstance. To learn
// more, see Cluster Query Language (path_to_url
// in the Amazon Elastic Container Service Developer Guide.
Expression *string `locationName:"expression" type:"string"`
// The type of constraint. Use distinctInstance to ensure that each task in
// a particular group is running on a different container instance. Use memberOf
// to restrict the selection to a group of valid candidates.
Type *string `locationName:"type" type:"string" enum:"PlacementConstraintType"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PlacementConstraint) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PlacementConstraint) GoString() string {
return s.String()
}
// SetExpression sets the Expression field's value.
func (s *PlacementConstraint) SetExpression(v string) *PlacementConstraint {
s.Expression = &v
return s
}
// SetType sets the Type field's value.
func (s *PlacementConstraint) SetType(v string) *PlacementConstraint {
s.Type = &v
return s
}
// The task placement strategy for a task or service. To learn more, see Task
// Placement Strategies (path_to_url
// in the Amazon Elastic Container Service Service Developer Guide.
type PlacementStrategy struct {
_ struct{} `type:"structure"`
// The field to apply the placement strategy against. For the spread placement
// strategy, valid values are instanceId (or host, which has the same effect),
// or any platform or custom attribute that is applied to a container instance,
// such as attribute:ecs.availability-zone. For the binpack placement strategy,
// valid values are cpu and memory. For the random placement strategy, this
// field is not used.
Field *string `locationName:"field" type:"string"`
// The type of placement strategy. The random placement strategy randomly places
// tasks on available candidates. The spread placement strategy spreads placement
// across available candidates evenly based on the field parameter. The binpack
// strategy places tasks on available candidates that have the least available
// amount of the resource that is specified with the field parameter. For example,
// if you binpack on memory, a task is placed on the instance with the least
// amount of remaining memory (but still enough to run the task).
Type *string `locationName:"type" type:"string" enum:"PlacementStrategyType"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PlacementStrategy) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PlacementStrategy) GoString() string {
return s.String()
}
// SetField sets the Field field's value.
func (s *PlacementStrategy) SetField(v string) *PlacementStrategy {
s.Field = &v
return s
}
// SetType sets the Type field's value.
func (s *PlacementStrategy) SetType(v string) *PlacementStrategy {
s.Type = &v
return s
}
// The event bus policy is too long. For more information, see the limits.
type PolicyLengthExceededException struct {
_ struct{} `type:"structure"`
RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`
Message_ *string `locationName:"message" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PolicyLengthExceededException) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PolicyLengthExceededException) GoString() string {
return s.String()
}
func newErrorPolicyLengthExceededException(v protocol.ResponseMetadata) error {
return &PolicyLengthExceededException{
RespMetadata: v,
}
}
// Code returns the exception type name.
func (s *PolicyLengthExceededException) Code() string {
return "PolicyLengthExceededException"
}
// Message returns the exception's message.
func (s *PolicyLengthExceededException) Message() string {
if s.Message_ != nil {
return *s.Message_
}
return ""
}
// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *PolicyLengthExceededException) OrigErr() error {
return nil
}
func (s *PolicyLengthExceededException) Error() string {
return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}
// Status code returns the HTTP status code for the request's response error.
func (s *PolicyLengthExceededException) StatusCode() int {
return s.RespMetadata.StatusCode
}
// RequestID returns the service's response RequestID for request.
func (s *PolicyLengthExceededException) RequestID() string {
return s.RespMetadata.RequestID
}
type PutEventsInput struct {
_ struct{} `type:"structure"`
// The entry that defines an event in your system. You can specify several parameters
// for the entry such as the source and type of the event, resources associated
// with the event, and so on.
//
// Entries is a required field
Entries []*PutEventsRequestEntry `min:"1" type:"list" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutEventsInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutEventsInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *PutEventsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "PutEventsInput"}
if s.Entries == nil {
invalidParams.Add(request.NewErrParamRequired("Entries"))
}
if s.Entries != nil && len(s.Entries) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Entries", 1))
}
if s.Entries != nil {
for i, v := range s.Entries {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Entries", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetEntries sets the Entries field's value.
func (s *PutEventsInput) SetEntries(v []*PutEventsRequestEntry) *PutEventsInput {
s.Entries = v
return s
}
type PutEventsOutput struct {
_ struct{} `type:"structure"`
// The successfully and unsuccessfully ingested events results. If the ingestion
// was successful, the entry has the event ID in it. Otherwise, you can use
// the error code and error message to identify the problem with the entry.
Entries []*PutEventsResultEntry `type:"list"`
// The number of failed entries.
FailedEntryCount *int64 `type:"integer"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutEventsOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutEventsOutput) GoString() string {
return s.String()
}
// SetEntries sets the Entries field's value.
func (s *PutEventsOutput) SetEntries(v []*PutEventsResultEntry) *PutEventsOutput {
s.Entries = v
return s
}
// SetFailedEntryCount sets the FailedEntryCount field's value.
func (s *PutEventsOutput) SetFailedEntryCount(v int64) *PutEventsOutput {
s.FailedEntryCount = &v
return s
}
// Represents an event to be submitted.
type PutEventsRequestEntry struct {
_ struct{} `type:"structure"`
// A valid JSON string. There is no other schema imposed. The JSON string may
// contain fields and nested subobjects.
Detail *string `type:"string"`
// Free-form string used to decide what fields to expect in the event detail.
DetailType *string `type:"string"`
// The name or ARN of the event bus to receive the event. Only the rules that
// are associated with this event bus are used to match the event. If you omit
// this, the default event bus is used.
EventBusName *string `min:"1" type:"string"`
// Amazon Web Services resources, identified by Amazon Resource Name (ARN),
// which the event primarily concerns. Any number, including zero, may be present.
Resources []*string `type:"list"`
// The source of the event.
Source *string `type:"string"`
// The time stamp of the event, per RFC3339 (path_to_url
// If no time stamp is provided, the time stamp of the PutEvents (path_to_url
// call is used.
Time *time.Time `type:"timestamp"`
// An X-Ray trade header, which is an http header (X-Amzn-Trace-Id) that contains
// the trace-id associated with the event.
//
// To learn more about X-Ray trace headers, see Tracing header (path_to_url#xray-concepts-tracingheader)
// in the X-Ray Developer Guide.
TraceHeader *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutEventsRequestEntry) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutEventsRequestEntry) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *PutEventsRequestEntry) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "PutEventsRequestEntry"}
if s.EventBusName != nil && len(*s.EventBusName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("EventBusName", 1))
}
if s.TraceHeader != nil && len(*s.TraceHeader) < 1 {
invalidParams.Add(request.NewErrParamMinLen("TraceHeader", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetDetail sets the Detail field's value.
func (s *PutEventsRequestEntry) SetDetail(v string) *PutEventsRequestEntry {
s.Detail = &v
return s
}
// SetDetailType sets the DetailType field's value.
func (s *PutEventsRequestEntry) SetDetailType(v string) *PutEventsRequestEntry {
s.DetailType = &v
return s
}
// SetEventBusName sets the EventBusName field's value.
func (s *PutEventsRequestEntry) SetEventBusName(v string) *PutEventsRequestEntry {
s.EventBusName = &v
return s
}
// SetResources sets the Resources field's value.
func (s *PutEventsRequestEntry) SetResources(v []*string) *PutEventsRequestEntry {
s.Resources = v
return s
}
// SetSource sets the Source field's value.
func (s *PutEventsRequestEntry) SetSource(v string) *PutEventsRequestEntry {
s.Source = &v
return s
}
// SetTime sets the Time field's value.
func (s *PutEventsRequestEntry) SetTime(v time.Time) *PutEventsRequestEntry {
s.Time = &v
return s
}
// SetTraceHeader sets the TraceHeader field's value.
func (s *PutEventsRequestEntry) SetTraceHeader(v string) *PutEventsRequestEntry {
s.TraceHeader = &v
return s
}
// Represents an event that failed to be submitted.
type PutEventsResultEntry struct {
_ struct{} `type:"structure"`
// The error code that indicates why the event submission failed.
ErrorCode *string `type:"string"`
// The error message that explains why the event submission failed.
ErrorMessage *string `type:"string"`
// The ID of the event.
EventId *string `type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutEventsResultEntry) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutEventsResultEntry) GoString() string {
return s.String()
}
// SetErrorCode sets the ErrorCode field's value.
func (s *PutEventsResultEntry) SetErrorCode(v string) *PutEventsResultEntry {
s.ErrorCode = &v
return s
}
// SetErrorMessage sets the ErrorMessage field's value.
func (s *PutEventsResultEntry) SetErrorMessage(v string) *PutEventsResultEntry {
s.ErrorMessage = &v
return s
}
// SetEventId sets the EventId field's value.
func (s *PutEventsResultEntry) SetEventId(v string) *PutEventsResultEntry {
s.EventId = &v
return s
}
type PutPartnerEventsInput struct {
_ struct{} `type:"structure"`
// The list of events to write to the event bus.
//
// Entries is a required field
Entries []*PutPartnerEventsRequestEntry `min:"1" type:"list" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutPartnerEventsInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutPartnerEventsInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *PutPartnerEventsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "PutPartnerEventsInput"}
if s.Entries == nil {
invalidParams.Add(request.NewErrParamRequired("Entries"))
}
if s.Entries != nil && len(s.Entries) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Entries", 1))
}
if s.Entries != nil {
for i, v := range s.Entries {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Entries", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetEntries sets the Entries field's value.
func (s *PutPartnerEventsInput) SetEntries(v []*PutPartnerEventsRequestEntry) *PutPartnerEventsInput {
s.Entries = v
return s
}
type PutPartnerEventsOutput struct {
_ struct{} `type:"structure"`
// The list of events from this operation that were successfully written to
// the partner event bus.
Entries []*PutPartnerEventsResultEntry `type:"list"`
// The number of events from this operation that could not be written to the
// partner event bus.
FailedEntryCount *int64 `type:"integer"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutPartnerEventsOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutPartnerEventsOutput) GoString() string {
return s.String()
}
// SetEntries sets the Entries field's value.
func (s *PutPartnerEventsOutput) SetEntries(v []*PutPartnerEventsResultEntry) *PutPartnerEventsOutput {
s.Entries = v
return s
}
// SetFailedEntryCount sets the FailedEntryCount field's value.
func (s *PutPartnerEventsOutput) SetFailedEntryCount(v int64) *PutPartnerEventsOutput {
s.FailedEntryCount = &v
return s
}
// The details about an event generated by an SaaS partner.
type PutPartnerEventsRequestEntry struct {
_ struct{} `type:"structure"`
// A valid JSON string. There is no other schema imposed. The JSON string may
// contain fields and nested subobjects.
Detail *string `type:"string"`
// A free-form string used to decide what fields to expect in the event detail.
DetailType *string `type:"string"`
// Amazon Web Services resources, identified by Amazon Resource Name (ARN),
// which the event primarily concerns. Any number, including zero, may be present.
Resources []*string `type:"list"`
// The event source that is generating the entry.
Source *string `min:"1" type:"string"`
// The date and time of the event.
Time *time.Time `type:"timestamp"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutPartnerEventsRequestEntry) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutPartnerEventsRequestEntry) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *PutPartnerEventsRequestEntry) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "PutPartnerEventsRequestEntry"}
if s.Source != nil && len(*s.Source) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Source", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetDetail sets the Detail field's value.
func (s *PutPartnerEventsRequestEntry) SetDetail(v string) *PutPartnerEventsRequestEntry {
s.Detail = &v
return s
}
// SetDetailType sets the DetailType field's value.
func (s *PutPartnerEventsRequestEntry) SetDetailType(v string) *PutPartnerEventsRequestEntry {
s.DetailType = &v
return s
}
// SetResources sets the Resources field's value.
func (s *PutPartnerEventsRequestEntry) SetResources(v []*string) *PutPartnerEventsRequestEntry {
s.Resources = v
return s
}
// SetSource sets the Source field's value.
func (s *PutPartnerEventsRequestEntry) SetSource(v string) *PutPartnerEventsRequestEntry {
s.Source = &v
return s
}
// SetTime sets the Time field's value.
func (s *PutPartnerEventsRequestEntry) SetTime(v time.Time) *PutPartnerEventsRequestEntry {
s.Time = &v
return s
}
// Represents an event that a partner tried to generate, but failed.
type PutPartnerEventsResultEntry struct {
_ struct{} `type:"structure"`
// The error code that indicates why the event submission failed.
ErrorCode *string `type:"string"`
// The error message that explains why the event submission failed.
ErrorMessage *string `type:"string"`
// The ID of the event.
EventId *string `type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutPartnerEventsResultEntry) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutPartnerEventsResultEntry) GoString() string {
return s.String()
}
// SetErrorCode sets the ErrorCode field's value.
func (s *PutPartnerEventsResultEntry) SetErrorCode(v string) *PutPartnerEventsResultEntry {
s.ErrorCode = &v
return s
}
// SetErrorMessage sets the ErrorMessage field's value.
func (s *PutPartnerEventsResultEntry) SetErrorMessage(v string) *PutPartnerEventsResultEntry {
s.ErrorMessage = &v
return s
}
// SetEventId sets the EventId field's value.
func (s *PutPartnerEventsResultEntry) SetEventId(v string) *PutPartnerEventsResultEntry {
s.EventId = &v
return s
}
type PutPermissionInput struct {
_ struct{} `type:"structure"`
// The action that you are enabling the other account to perform.
Action *string `min:"1" type:"string"`
// This parameter enables you to limit the permission to accounts that fulfill
// a certain condition, such as being a member of a certain Amazon Web Services
// organization. For more information about Amazon Web Services Organizations,
// see What Is Amazon Web Services Organizations (path_to_url
// in the Amazon Web Services Organizations User Guide.
//
// If you specify Condition with an Amazon Web Services organization ID, and
// specify "*" as the value for Principal, you grant permission to all the accounts
// in the named organization.
//
// The Condition is a JSON string which must contain Type, Key, and Value fields.
Condition *Condition `type:"structure"`
// The name of the event bus associated with the rule. If you omit this, the
// default event bus is used.
EventBusName *string `min:"1" type:"string"`
// A JSON string that describes the permission policy statement. You can include
// a Policy parameter in the request instead of using the StatementId, Action,
// Principal, or Condition parameters.
Policy *string `type:"string"`
// The 12-digit Amazon Web Services account ID that you are permitting to put
// events to your default event bus. Specify "*" to permit any account to put
// events to your default event bus.
//
// If you specify "*" without specifying Condition, avoid creating rules that
// may match undesirable events. To create more secure rules, make sure that
// the event pattern for each rule contains an account field with a specific
// account ID from which to receive events. Rules with an account field do not
// match any events sent from other accounts.
Principal *string `min:"1" type:"string"`
// An identifier string for the external account that you are granting permissions
// to. If you later want to revoke the permission for this external account,
// specify this StatementId when you run RemovePermission (path_to_url
StatementId *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutPermissionInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutPermissionInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *PutPermissionInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "PutPermissionInput"}
if s.Action != nil && len(*s.Action) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Action", 1))
}
if s.EventBusName != nil && len(*s.EventBusName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("EventBusName", 1))
}
if s.Principal != nil && len(*s.Principal) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Principal", 1))
}
if s.StatementId != nil && len(*s.StatementId) < 1 {
invalidParams.Add(request.NewErrParamMinLen("StatementId", 1))
}
if s.Condition != nil {
if err := s.Condition.Validate(); err != nil {
invalidParams.AddNested("Condition", err.(request.ErrInvalidParams))
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetAction sets the Action field's value.
func (s *PutPermissionInput) SetAction(v string) *PutPermissionInput {
s.Action = &v
return s
}
// SetCondition sets the Condition field's value.
func (s *PutPermissionInput) SetCondition(v *Condition) *PutPermissionInput {
s.Condition = v
return s
}
// SetEventBusName sets the EventBusName field's value.
func (s *PutPermissionInput) SetEventBusName(v string) *PutPermissionInput {
s.EventBusName = &v
return s
}
// SetPolicy sets the Policy field's value.
func (s *PutPermissionInput) SetPolicy(v string) *PutPermissionInput {
s.Policy = &v
return s
}
// SetPrincipal sets the Principal field's value.
func (s *PutPermissionInput) SetPrincipal(v string) *PutPermissionInput {
s.Principal = &v
return s
}
// SetStatementId sets the StatementId field's value.
func (s *PutPermissionInput) SetStatementId(v string) *PutPermissionInput {
s.StatementId = &v
return s
}
type PutPermissionOutput struct {
_ struct{} `type:"structure"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutPermissionOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutPermissionOutput) GoString() string {
return s.String()
}
type PutRuleInput struct {
_ struct{} `type:"structure"`
// A description of the rule.
Description *string `type:"string"`
// The name or ARN of the event bus to associate with this rule. If you omit
// this, the default event bus is used.
EventBusName *string `min:"1" type:"string"`
// The event pattern. For more information, see Events and Event Patterns (path_to_url
// in the Amazon EventBridge User Guide.
EventPattern *string `type:"string"`
// The name of the rule that you are creating or updating.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
// The Amazon Resource Name (ARN) of the IAM role associated with the rule.
//
// If you're setting an event bus in another account as the target and that
// account granted permission to your account through an organization instead
// of directly by the account ID, you must specify a RoleArn with proper permissions
// in the Target structure, instead of here in this parameter.
RoleArn *string `min:"1" type:"string"`
// The scheduling expression. For example, "cron(0 20 * * ? *)" or "rate(5 minutes)".
ScheduleExpression *string `type:"string"`
// Indicates whether the rule is enabled or disabled.
State *string `type:"string" enum:"RuleState"`
// The list of key-value pairs to associate with the rule.
Tags []*Tag `type:"list"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutRuleInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutRuleInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *PutRuleInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "PutRuleInput"}
if s.EventBusName != nil && len(*s.EventBusName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("EventBusName", 1))
}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if s.RoleArn != nil && len(*s.RoleArn) < 1 {
invalidParams.Add(request.NewErrParamMinLen("RoleArn", 1))
}
if s.Tags != nil {
for i, v := range s.Tags {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetDescription sets the Description field's value.
func (s *PutRuleInput) SetDescription(v string) *PutRuleInput {
s.Description = &v
return s
}
// SetEventBusName sets the EventBusName field's value.
func (s *PutRuleInput) SetEventBusName(v string) *PutRuleInput {
s.EventBusName = &v
return s
}
// SetEventPattern sets the EventPattern field's value.
func (s *PutRuleInput) SetEventPattern(v string) *PutRuleInput {
s.EventPattern = &v
return s
}
// SetName sets the Name field's value.
func (s *PutRuleInput) SetName(v string) *PutRuleInput {
s.Name = &v
return s
}
// SetRoleArn sets the RoleArn field's value.
func (s *PutRuleInput) SetRoleArn(v string) *PutRuleInput {
s.RoleArn = &v
return s
}
// SetScheduleExpression sets the ScheduleExpression field's value.
func (s *PutRuleInput) SetScheduleExpression(v string) *PutRuleInput {
s.ScheduleExpression = &v
return s
}
// SetState sets the State field's value.
func (s *PutRuleInput) SetState(v string) *PutRuleInput {
s.State = &v
return s
}
// SetTags sets the Tags field's value.
func (s *PutRuleInput) SetTags(v []*Tag) *PutRuleInput {
s.Tags = v
return s
}
type PutRuleOutput struct {
_ struct{} `type:"structure"`
// The Amazon Resource Name (ARN) of the rule.
RuleArn *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutRuleOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutRuleOutput) GoString() string {
return s.String()
}
// SetRuleArn sets the RuleArn field's value.
func (s *PutRuleOutput) SetRuleArn(v string) *PutRuleOutput {
s.RuleArn = &v
return s
}
type PutTargetsInput struct {
_ struct{} `type:"structure"`
// The name or ARN of the event bus associated with the rule. If you omit this,
// the default event bus is used.
EventBusName *string `min:"1" type:"string"`
// The name of the rule.
//
// Rule is a required field
Rule *string `min:"1" type:"string" required:"true"`
// The targets to update or add to the rule.
//
// Targets is a required field
Targets []*Target `min:"1" type:"list" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutTargetsInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutTargetsInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *PutTargetsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "PutTargetsInput"}
if s.EventBusName != nil && len(*s.EventBusName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("EventBusName", 1))
}
if s.Rule == nil {
invalidParams.Add(request.NewErrParamRequired("Rule"))
}
if s.Rule != nil && len(*s.Rule) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Rule", 1))
}
if s.Targets == nil {
invalidParams.Add(request.NewErrParamRequired("Targets"))
}
if s.Targets != nil && len(s.Targets) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Targets", 1))
}
if s.Targets != nil {
for i, v := range s.Targets {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Targets", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetEventBusName sets the EventBusName field's value.
func (s *PutTargetsInput) SetEventBusName(v string) *PutTargetsInput {
s.EventBusName = &v
return s
}
// SetRule sets the Rule field's value.
func (s *PutTargetsInput) SetRule(v string) *PutTargetsInput {
s.Rule = &v
return s
}
// SetTargets sets the Targets field's value.
func (s *PutTargetsInput) SetTargets(v []*Target) *PutTargetsInput {
s.Targets = v
return s
}
type PutTargetsOutput struct {
_ struct{} `type:"structure"`
// The failed target entries.
FailedEntries []*PutTargetsResultEntry `type:"list"`
// The number of failed entries.
FailedEntryCount *int64 `type:"integer"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutTargetsOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutTargetsOutput) GoString() string {
return s.String()
}
// SetFailedEntries sets the FailedEntries field's value.
func (s *PutTargetsOutput) SetFailedEntries(v []*PutTargetsResultEntry) *PutTargetsOutput {
s.FailedEntries = v
return s
}
// SetFailedEntryCount sets the FailedEntryCount field's value.
func (s *PutTargetsOutput) SetFailedEntryCount(v int64) *PutTargetsOutput {
s.FailedEntryCount = &v
return s
}
// Represents a target that failed to be added to a rule.
type PutTargetsResultEntry struct {
_ struct{} `type:"structure"`
// The error code that indicates why the target addition failed. If the value
// is ConcurrentModificationException, too many requests were made at the same
// time.
ErrorCode *string `type:"string"`
// The error message that explains why the target addition failed.
ErrorMessage *string `type:"string"`
// The ID of the target.
TargetId *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutTargetsResultEntry) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s PutTargetsResultEntry) GoString() string {
return s.String()
}
// SetErrorCode sets the ErrorCode field's value.
func (s *PutTargetsResultEntry) SetErrorCode(v string) *PutTargetsResultEntry {
s.ErrorCode = &v
return s
}
// SetErrorMessage sets the ErrorMessage field's value.
func (s *PutTargetsResultEntry) SetErrorMessage(v string) *PutTargetsResultEntry {
s.ErrorMessage = &v
return s
}
// SetTargetId sets the TargetId field's value.
func (s *PutTargetsResultEntry) SetTargetId(v string) *PutTargetsResultEntry {
s.TargetId = &v
return s
}
// These are custom parameters to be used when the target is a Amazon Redshift
// cluster to invoke the Amazon Redshift Data API ExecuteStatement based on
// EventBridge events.
type RedshiftDataParameters struct {
_ struct{} `type:"structure"`
// The name of the database. Required when authenticating using temporary credentials.
//
// Database is a required field
Database *string `min:"1" type:"string" required:"true"`
// The database user name. Required when authenticating using temporary credentials.
DbUser *string `min:"1" type:"string"`
// The name or ARN of the secret that enables access to the database. Required
// when authenticating using Amazon Web Services Secrets Manager.
SecretManagerArn *string `min:"1" type:"string"`
// The SQL statement text to run.
//
// Sql is a required field
Sql *string `min:"1" type:"string" required:"true"`
// The name of the SQL statement. You can name the SQL statement when you create
// it to identify the query.
StatementName *string `min:"1" type:"string"`
// Indicates whether to send an event back to EventBridge after the SQL statement
// runs.
WithEvent *bool `type:"boolean"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s RedshiftDataParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s RedshiftDataParameters) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *RedshiftDataParameters) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "RedshiftDataParameters"}
if s.Database == nil {
invalidParams.Add(request.NewErrParamRequired("Database"))
}
if s.Database != nil && len(*s.Database) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Database", 1))
}
if s.DbUser != nil && len(*s.DbUser) < 1 {
invalidParams.Add(request.NewErrParamMinLen("DbUser", 1))
}
if s.SecretManagerArn != nil && len(*s.SecretManagerArn) < 1 {
invalidParams.Add(request.NewErrParamMinLen("SecretManagerArn", 1))
}
if s.Sql == nil {
invalidParams.Add(request.NewErrParamRequired("Sql"))
}
if s.Sql != nil && len(*s.Sql) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Sql", 1))
}
if s.StatementName != nil && len(*s.StatementName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("StatementName", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetDatabase sets the Database field's value.
func (s *RedshiftDataParameters) SetDatabase(v string) *RedshiftDataParameters {
s.Database = &v
return s
}
// SetDbUser sets the DbUser field's value.
func (s *RedshiftDataParameters) SetDbUser(v string) *RedshiftDataParameters {
s.DbUser = &v
return s
}
// SetSecretManagerArn sets the SecretManagerArn field's value.
func (s *RedshiftDataParameters) SetSecretManagerArn(v string) *RedshiftDataParameters {
s.SecretManagerArn = &v
return s
}
// SetSql sets the Sql field's value.
func (s *RedshiftDataParameters) SetSql(v string) *RedshiftDataParameters {
s.Sql = &v
return s
}
// SetStatementName sets the StatementName field's value.
func (s *RedshiftDataParameters) SetStatementName(v string) *RedshiftDataParameters {
s.StatementName = &v
return s
}
// SetWithEvent sets the WithEvent field's value.
func (s *RedshiftDataParameters) SetWithEvent(v bool) *RedshiftDataParameters {
s.WithEvent = &v
return s
}
type RemovePermissionInput struct {
_ struct{} `type:"structure"`
// The name of the event bus to revoke permissions for. If you omit this, the
// default event bus is used.
EventBusName *string `min:"1" type:"string"`
// Specifies whether to remove all permissions.
RemoveAllPermissions *bool `type:"boolean"`
// The statement ID corresponding to the account that is no longer allowed to
// put events to the default event bus.
StatementId *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s RemovePermissionInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s RemovePermissionInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *RemovePermissionInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "RemovePermissionInput"}
if s.EventBusName != nil && len(*s.EventBusName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("EventBusName", 1))
}
if s.StatementId != nil && len(*s.StatementId) < 1 {
invalidParams.Add(request.NewErrParamMinLen("StatementId", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetEventBusName sets the EventBusName field's value.
func (s *RemovePermissionInput) SetEventBusName(v string) *RemovePermissionInput {
s.EventBusName = &v
return s
}
// SetRemoveAllPermissions sets the RemoveAllPermissions field's value.
func (s *RemovePermissionInput) SetRemoveAllPermissions(v bool) *RemovePermissionInput {
s.RemoveAllPermissions = &v
return s
}
// SetStatementId sets the StatementId field's value.
func (s *RemovePermissionInput) SetStatementId(v string) *RemovePermissionInput {
s.StatementId = &v
return s
}
type RemovePermissionOutput struct {
_ struct{} `type:"structure"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s RemovePermissionOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s RemovePermissionOutput) GoString() string {
return s.String()
}
type RemoveTargetsInput struct {
_ struct{} `type:"structure"`
// The name or ARN of the event bus associated with the rule. If you omit this,
// the default event bus is used.
EventBusName *string `min:"1" type:"string"`
// If this is a managed rule, created by an Amazon Web Services service on your
// behalf, you must specify Force as True to remove targets. This parameter
// is ignored for rules that are not managed rules. You can check whether a
// rule is a managed rule by using DescribeRule or ListRules and checking the
// ManagedBy field of the response.
Force *bool `type:"boolean"`
// The IDs of the targets to remove from the rule.
//
// Ids is a required field
Ids []*string `min:"1" type:"list" required:"true"`
// The name of the rule.
//
// Rule is a required field
Rule *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s RemoveTargetsInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s RemoveTargetsInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *RemoveTargetsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "RemoveTargetsInput"}
if s.EventBusName != nil && len(*s.EventBusName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("EventBusName", 1))
}
if s.Ids == nil {
invalidParams.Add(request.NewErrParamRequired("Ids"))
}
if s.Ids != nil && len(s.Ids) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Ids", 1))
}
if s.Rule == nil {
invalidParams.Add(request.NewErrParamRequired("Rule"))
}
if s.Rule != nil && len(*s.Rule) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Rule", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetEventBusName sets the EventBusName field's value.
func (s *RemoveTargetsInput) SetEventBusName(v string) *RemoveTargetsInput {
s.EventBusName = &v
return s
}
// SetForce sets the Force field's value.
func (s *RemoveTargetsInput) SetForce(v bool) *RemoveTargetsInput {
s.Force = &v
return s
}
// SetIds sets the Ids field's value.
func (s *RemoveTargetsInput) SetIds(v []*string) *RemoveTargetsInput {
s.Ids = v
return s
}
// SetRule sets the Rule field's value.
func (s *RemoveTargetsInput) SetRule(v string) *RemoveTargetsInput {
s.Rule = &v
return s
}
type RemoveTargetsOutput struct {
_ struct{} `type:"structure"`
// The failed target entries.
FailedEntries []*RemoveTargetsResultEntry `type:"list"`
// The number of failed entries.
FailedEntryCount *int64 `type:"integer"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s RemoveTargetsOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s RemoveTargetsOutput) GoString() string {
return s.String()
}
// SetFailedEntries sets the FailedEntries field's value.
func (s *RemoveTargetsOutput) SetFailedEntries(v []*RemoveTargetsResultEntry) *RemoveTargetsOutput {
s.FailedEntries = v
return s
}
// SetFailedEntryCount sets the FailedEntryCount field's value.
func (s *RemoveTargetsOutput) SetFailedEntryCount(v int64) *RemoveTargetsOutput {
s.FailedEntryCount = &v
return s
}
// Represents a target that failed to be removed from a rule.
type RemoveTargetsResultEntry struct {
_ struct{} `type:"structure"`
// The error code that indicates why the target removal failed. If the value
// is ConcurrentModificationException, too many requests were made at the same
// time.
ErrorCode *string `type:"string"`
// The error message that explains why the target removal failed.
ErrorMessage *string `type:"string"`
// The ID of the target.
TargetId *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s RemoveTargetsResultEntry) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s RemoveTargetsResultEntry) GoString() string {
return s.String()
}
// SetErrorCode sets the ErrorCode field's value.
func (s *RemoveTargetsResultEntry) SetErrorCode(v string) *RemoveTargetsResultEntry {
s.ErrorCode = &v
return s
}
// SetErrorMessage sets the ErrorMessage field's value.
func (s *RemoveTargetsResultEntry) SetErrorMessage(v string) *RemoveTargetsResultEntry {
s.ErrorMessage = &v
return s
}
// SetTargetId sets the TargetId field's value.
func (s *RemoveTargetsResultEntry) SetTargetId(v string) *RemoveTargetsResultEntry {
s.TargetId = &v
return s
}
// A Replay object that contains details about a replay.
type Replay struct {
_ struct{} `type:"structure"`
// A time stamp for the time to start replaying events. Any event with a creation
// time prior to the EventEndTime specified is replayed.
EventEndTime *time.Time `type:"timestamp"`
// A time stamp for the time that the last event was replayed.
EventLastReplayedTime *time.Time `type:"timestamp"`
// The ARN of the archive to replay event from.
EventSourceArn *string `min:"1" type:"string"`
// A time stamp for the time to start replaying events. This is determined by
// the time in the event as described in Time (path_to_url#eventbridge-Type-PutEventsRequestEntry-Time).
EventStartTime *time.Time `type:"timestamp"`
// A time stamp for the time that the replay completed.
ReplayEndTime *time.Time `type:"timestamp"`
// The name of the replay.
ReplayName *string `min:"1" type:"string"`
// A time stamp for the time that the replay started.
ReplayStartTime *time.Time `type:"timestamp"`
// The current state of the replay.
State *string `type:"string" enum:"ReplayState"`
// A description of why the replay is in the current state.
StateReason *string `type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s Replay) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s Replay) GoString() string {
return s.String()
}
// SetEventEndTime sets the EventEndTime field's value.
func (s *Replay) SetEventEndTime(v time.Time) *Replay {
s.EventEndTime = &v
return s
}
// SetEventLastReplayedTime sets the EventLastReplayedTime field's value.
func (s *Replay) SetEventLastReplayedTime(v time.Time) *Replay {
s.EventLastReplayedTime = &v
return s
}
// SetEventSourceArn sets the EventSourceArn field's value.
func (s *Replay) SetEventSourceArn(v string) *Replay {
s.EventSourceArn = &v
return s
}
// SetEventStartTime sets the EventStartTime field's value.
func (s *Replay) SetEventStartTime(v time.Time) *Replay {
s.EventStartTime = &v
return s
}
// SetReplayEndTime sets the ReplayEndTime field's value.
func (s *Replay) SetReplayEndTime(v time.Time) *Replay {
s.ReplayEndTime = &v
return s
}
// SetReplayName sets the ReplayName field's value.
func (s *Replay) SetReplayName(v string) *Replay {
s.ReplayName = &v
return s
}
// SetReplayStartTime sets the ReplayStartTime field's value.
func (s *Replay) SetReplayStartTime(v time.Time) *Replay {
s.ReplayStartTime = &v
return s
}
// SetState sets the State field's value.
func (s *Replay) SetState(v string) *Replay {
s.State = &v
return s
}
// SetStateReason sets the StateReason field's value.
func (s *Replay) SetStateReason(v string) *Replay {
s.StateReason = &v
return s
}
// A ReplayDestination object that contains details about a replay.
type ReplayDestination struct {
_ struct{} `type:"structure"`
// The ARN of the event bus to replay event to. You can replay events only to
// the event bus specified to create the archive.
//
// Arn is a required field
Arn *string `min:"1" type:"string" required:"true"`
// A list of ARNs for rules to replay events to.
FilterArns []*string `type:"list"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ReplayDestination) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ReplayDestination) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *ReplayDestination) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "ReplayDestination"}
if s.Arn == nil {
invalidParams.Add(request.NewErrParamRequired("Arn"))
}
if s.Arn != nil && len(*s.Arn) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Arn", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetArn sets the Arn field's value.
func (s *ReplayDestination) SetArn(v string) *ReplayDestination {
s.Arn = &v
return s
}
// SetFilterArns sets the FilterArns field's value.
func (s *ReplayDestination) SetFilterArns(v []*string) *ReplayDestination {
s.FilterArns = v
return s
}
// The resource you are trying to create already exists.
type ResourceAlreadyExistsException struct {
_ struct{} `type:"structure"`
RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`
Message_ *string `locationName:"message" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ResourceAlreadyExistsException) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ResourceAlreadyExistsException) GoString() string {
return s.String()
}
func newErrorResourceAlreadyExistsException(v protocol.ResponseMetadata) error {
return &ResourceAlreadyExistsException{
RespMetadata: v,
}
}
// Code returns the exception type name.
func (s *ResourceAlreadyExistsException) Code() string {
return "ResourceAlreadyExistsException"
}
// Message returns the exception's message.
func (s *ResourceAlreadyExistsException) Message() string {
if s.Message_ != nil {
return *s.Message_
}
return ""
}
// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *ResourceAlreadyExistsException) OrigErr() error {
return nil
}
func (s *ResourceAlreadyExistsException) Error() string {
return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}
// Status code returns the HTTP status code for the request's response error.
func (s *ResourceAlreadyExistsException) StatusCode() int {
return s.RespMetadata.StatusCode
}
// RequestID returns the service's response RequestID for request.
func (s *ResourceAlreadyExistsException) RequestID() string {
return s.RespMetadata.RequestID
}
// An entity that you specified does not exist.
type ResourceNotFoundException struct {
_ struct{} `type:"structure"`
RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`
Message_ *string `locationName:"message" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ResourceNotFoundException) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s ResourceNotFoundException) GoString() string {
return s.String()
}
func newErrorResourceNotFoundException(v protocol.ResponseMetadata) error {
return &ResourceNotFoundException{
RespMetadata: v,
}
}
// Code returns the exception type name.
func (s *ResourceNotFoundException) Code() string {
return "ResourceNotFoundException"
}
// Message returns the exception's message.
func (s *ResourceNotFoundException) Message() string {
if s.Message_ != nil {
return *s.Message_
}
return ""
}
// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *ResourceNotFoundException) OrigErr() error {
return nil
}
func (s *ResourceNotFoundException) Error() string {
return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}
// Status code returns the HTTP status code for the request's response error.
func (s *ResourceNotFoundException) StatusCode() int {
return s.RespMetadata.StatusCode
}
// RequestID returns the service's response RequestID for request.
func (s *ResourceNotFoundException) RequestID() string {
return s.RespMetadata.RequestID
}
// A RetryPolicy object that includes information about the retry policy settings.
type RetryPolicy struct {
_ struct{} `type:"structure"`
// The maximum amount of time, in seconds, to continue to make retry attempts.
MaximumEventAgeInSeconds *int64 `min:"60" type:"integer"`
// The maximum number of retry attempts to make before the request fails. Retry
// attempts continue until either the maximum number of attempts is made or
// until the duration of the MaximumEventAgeInSeconds is met.
MaximumRetryAttempts *int64 `type:"integer"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s RetryPolicy) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s RetryPolicy) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *RetryPolicy) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "RetryPolicy"}
if s.MaximumEventAgeInSeconds != nil && *s.MaximumEventAgeInSeconds < 60 {
invalidParams.Add(request.NewErrParamMinValue("MaximumEventAgeInSeconds", 60))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetMaximumEventAgeInSeconds sets the MaximumEventAgeInSeconds field's value.
func (s *RetryPolicy) SetMaximumEventAgeInSeconds(v int64) *RetryPolicy {
s.MaximumEventAgeInSeconds = &v
return s
}
// SetMaximumRetryAttempts sets the MaximumRetryAttempts field's value.
func (s *RetryPolicy) SetMaximumRetryAttempts(v int64) *RetryPolicy {
s.MaximumRetryAttempts = &v
return s
}
// Contains information about a rule in Amazon EventBridge.
type Rule struct {
_ struct{} `type:"structure"`
// The Amazon Resource Name (ARN) of the rule.
Arn *string `min:"1" type:"string"`
// The description of the rule.
Description *string `type:"string"`
// The name or ARN of the event bus associated with the rule. If you omit this,
// the default event bus is used.
EventBusName *string `min:"1" type:"string"`
// The event pattern of the rule. For more information, see Events and Event
// Patterns (path_to_url
// in the Amazon EventBridge User Guide.
EventPattern *string `type:"string"`
// If the rule was created on behalf of your account by an Amazon Web Services
// service, this field displays the principal name of the service that created
// the rule.
ManagedBy *string `min:"1" type:"string"`
// The name of the rule.
Name *string `min:"1" type:"string"`
// The Amazon Resource Name (ARN) of the role that is used for target invocation.
//
// If you're setting an event bus in another account as the target and that
// account granted permission to your account through an organization instead
// of directly by the account ID, you must specify a RoleArn with proper permissions
// in the Target structure, instead of here in this parameter.
RoleArn *string `min:"1" type:"string"`
// The scheduling expression. For example, "cron(0 20 * * ? *)", "rate(5 minutes)".
// For more information, see Creating an Amazon EventBridge rule that runs on
// a schedule (path_to_url
ScheduleExpression *string `type:"string"`
// The state of the rule.
State *string `type:"string" enum:"RuleState"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s Rule) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s Rule) GoString() string {
return s.String()
}
// SetArn sets the Arn field's value.
func (s *Rule) SetArn(v string) *Rule {
s.Arn = &v
return s
}
// SetDescription sets the Description field's value.
func (s *Rule) SetDescription(v string) *Rule {
s.Description = &v
return s
}
// SetEventBusName sets the EventBusName field's value.
func (s *Rule) SetEventBusName(v string) *Rule {
s.EventBusName = &v
return s
}
// SetEventPattern sets the EventPattern field's value.
func (s *Rule) SetEventPattern(v string) *Rule {
s.EventPattern = &v
return s
}
// SetManagedBy sets the ManagedBy field's value.
func (s *Rule) SetManagedBy(v string) *Rule {
s.ManagedBy = &v
return s
}
// SetName sets the Name field's value.
func (s *Rule) SetName(v string) *Rule {
s.Name = &v
return s
}
// SetRoleArn sets the RoleArn field's value.
func (s *Rule) SetRoleArn(v string) *Rule {
s.RoleArn = &v
return s
}
// SetScheduleExpression sets the ScheduleExpression field's value.
func (s *Rule) SetScheduleExpression(v string) *Rule {
s.ScheduleExpression = &v
return s
}
// SetState sets the State field's value.
func (s *Rule) SetState(v string) *Rule {
s.State = &v
return s
}
// This parameter contains the criteria (either InstanceIds or a tag) used to
// specify which EC2 instances are to be sent the command.
type RunCommandParameters struct {
_ struct{} `type:"structure"`
// Currently, we support including only one RunCommandTarget block, which specifies
// either an array of InstanceIds or a tag.
//
// RunCommandTargets is a required field
RunCommandTargets []*RunCommandTarget `min:"1" type:"list" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s RunCommandParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s RunCommandParameters) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *RunCommandParameters) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "RunCommandParameters"}
if s.RunCommandTargets == nil {
invalidParams.Add(request.NewErrParamRequired("RunCommandTargets"))
}
if s.RunCommandTargets != nil && len(s.RunCommandTargets) < 1 {
invalidParams.Add(request.NewErrParamMinLen("RunCommandTargets", 1))
}
if s.RunCommandTargets != nil {
for i, v := range s.RunCommandTargets {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "RunCommandTargets", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetRunCommandTargets sets the RunCommandTargets field's value.
func (s *RunCommandParameters) SetRunCommandTargets(v []*RunCommandTarget) *RunCommandParameters {
s.RunCommandTargets = v
return s
}
// Information about the EC2 instances that are to be sent the command, specified
// as key-value pairs. Each RunCommandTarget block can include only one key,
// but this key may specify multiple values.
type RunCommandTarget struct {
_ struct{} `type:"structure"`
// Can be either tag: tag-key or InstanceIds.
//
// Key is a required field
Key *string `min:"1" type:"string" required:"true"`
// If Key is tag: tag-key, Values is a list of tag values. If Key is InstanceIds,
// Values is a list of Amazon EC2 instance IDs.
//
// Values is a required field
Values []*string `min:"1" type:"list" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s RunCommandTarget) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s RunCommandTarget) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *RunCommandTarget) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "RunCommandTarget"}
if s.Key == nil {
invalidParams.Add(request.NewErrParamRequired("Key"))
}
if s.Key != nil && len(*s.Key) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Key", 1))
}
if s.Values == nil {
invalidParams.Add(request.NewErrParamRequired("Values"))
}
if s.Values != nil && len(s.Values) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Values", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetKey sets the Key field's value.
func (s *RunCommandTarget) SetKey(v string) *RunCommandTarget {
s.Key = &v
return s
}
// SetValues sets the Values field's value.
func (s *RunCommandTarget) SetValues(v []*string) *RunCommandTarget {
s.Values = v
return s
}
// Name/Value pair of a parameter to start execution of a SageMaker Model Building
// Pipeline.
type SageMakerPipelineParameter struct {
_ struct{} `type:"structure"`
// Name of parameter to start execution of a SageMaker Model Building Pipeline.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
// Value of parameter to start execution of a SageMaker Model Building Pipeline.
//
// Value is a required field
Value *string `type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s SageMakerPipelineParameter) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s SageMakerPipelineParameter) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *SageMakerPipelineParameter) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "SageMakerPipelineParameter"}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if s.Value == nil {
invalidParams.Add(request.NewErrParamRequired("Value"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetName sets the Name field's value.
func (s *SageMakerPipelineParameter) SetName(v string) *SageMakerPipelineParameter {
s.Name = &v
return s
}
// SetValue sets the Value field's value.
func (s *SageMakerPipelineParameter) SetValue(v string) *SageMakerPipelineParameter {
s.Value = &v
return s
}
// These are custom parameters to use when the target is a SageMaker Model Building
// Pipeline that starts based on EventBridge events.
type SageMakerPipelineParameters struct {
_ struct{} `type:"structure"`
// List of Parameter names and values for SageMaker Model Building Pipeline
// execution.
PipelineParameterList []*SageMakerPipelineParameter `type:"list"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s SageMakerPipelineParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s SageMakerPipelineParameters) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *SageMakerPipelineParameters) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "SageMakerPipelineParameters"}
if s.PipelineParameterList != nil {
for i, v := range s.PipelineParameterList {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "PipelineParameterList", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetPipelineParameterList sets the PipelineParameterList field's value.
func (s *SageMakerPipelineParameters) SetPipelineParameterList(v []*SageMakerPipelineParameter) *SageMakerPipelineParameters {
s.PipelineParameterList = v
return s
}
// This structure includes the custom parameter to be used when the target is
// an SQS FIFO queue.
type SqsParameters struct {
_ struct{} `type:"structure"`
// The FIFO message group ID to use as the target.
MessageGroupId *string `type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s SqsParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s SqsParameters) GoString() string {
return s.String()
}
// SetMessageGroupId sets the MessageGroupId field's value.
func (s *SqsParameters) SetMessageGroupId(v string) *SqsParameters {
s.MessageGroupId = &v
return s
}
type StartReplayInput struct {
_ struct{} `type:"structure"`
// A description for the replay to start.
Description *string `type:"string"`
// A ReplayDestination object that includes details about the destination for
// the replay.
//
// Destination is a required field
Destination *ReplayDestination `type:"structure" required:"true"`
// A time stamp for the time to stop replaying events. Only events that occurred
// between the EventStartTime and EventEndTime are replayed.
//
// EventEndTime is a required field
EventEndTime *time.Time `type:"timestamp" required:"true"`
// The ARN of the archive to replay events from.
//
// EventSourceArn is a required field
EventSourceArn *string `min:"1" type:"string" required:"true"`
// A time stamp for the time to start replaying events. Only events that occurred
// between the EventStartTime and EventEndTime are replayed.
//
// EventStartTime is a required field
EventStartTime *time.Time `type:"timestamp" required:"true"`
// The name of the replay to start.
//
// ReplayName is a required field
ReplayName *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s StartReplayInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s StartReplayInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *StartReplayInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "StartReplayInput"}
if s.Destination == nil {
invalidParams.Add(request.NewErrParamRequired("Destination"))
}
if s.EventEndTime == nil {
invalidParams.Add(request.NewErrParamRequired("EventEndTime"))
}
if s.EventSourceArn == nil {
invalidParams.Add(request.NewErrParamRequired("EventSourceArn"))
}
if s.EventSourceArn != nil && len(*s.EventSourceArn) < 1 {
invalidParams.Add(request.NewErrParamMinLen("EventSourceArn", 1))
}
if s.EventStartTime == nil {
invalidParams.Add(request.NewErrParamRequired("EventStartTime"))
}
if s.ReplayName == nil {
invalidParams.Add(request.NewErrParamRequired("ReplayName"))
}
if s.ReplayName != nil && len(*s.ReplayName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ReplayName", 1))
}
if s.Destination != nil {
if err := s.Destination.Validate(); err != nil {
invalidParams.AddNested("Destination", err.(request.ErrInvalidParams))
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetDescription sets the Description field's value.
func (s *StartReplayInput) SetDescription(v string) *StartReplayInput {
s.Description = &v
return s
}
// SetDestination sets the Destination field's value.
func (s *StartReplayInput) SetDestination(v *ReplayDestination) *StartReplayInput {
s.Destination = v
return s
}
// SetEventEndTime sets the EventEndTime field's value.
func (s *StartReplayInput) SetEventEndTime(v time.Time) *StartReplayInput {
s.EventEndTime = &v
return s
}
// SetEventSourceArn sets the EventSourceArn field's value.
func (s *StartReplayInput) SetEventSourceArn(v string) *StartReplayInput {
s.EventSourceArn = &v
return s
}
// SetEventStartTime sets the EventStartTime field's value.
func (s *StartReplayInput) SetEventStartTime(v time.Time) *StartReplayInput {
s.EventStartTime = &v
return s
}
// SetReplayName sets the ReplayName field's value.
func (s *StartReplayInput) SetReplayName(v string) *StartReplayInput {
s.ReplayName = &v
return s
}
type StartReplayOutput struct {
_ struct{} `type:"structure"`
// The ARN of the replay.
ReplayArn *string `min:"1" type:"string"`
// The time at which the replay started.
ReplayStartTime *time.Time `type:"timestamp"`
// The state of the replay.
State *string `type:"string" enum:"ReplayState"`
// The reason that the replay is in the state.
StateReason *string `type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s StartReplayOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s StartReplayOutput) GoString() string {
return s.String()
}
// SetReplayArn sets the ReplayArn field's value.
func (s *StartReplayOutput) SetReplayArn(v string) *StartReplayOutput {
s.ReplayArn = &v
return s
}
// SetReplayStartTime sets the ReplayStartTime field's value.
func (s *StartReplayOutput) SetReplayStartTime(v time.Time) *StartReplayOutput {
s.ReplayStartTime = &v
return s
}
// SetState sets the State field's value.
func (s *StartReplayOutput) SetState(v string) *StartReplayOutput {
s.State = &v
return s
}
// SetStateReason sets the StateReason field's value.
func (s *StartReplayOutput) SetStateReason(v string) *StartReplayOutput {
s.StateReason = &v
return s
}
// A key-value pair associated with an Amazon Web Services resource. In EventBridge,
// rules and event buses support tagging.
type Tag struct {
_ struct{} `type:"structure"`
// A string you can use to assign a value. The combination of tag keys and values
// can help you organize and categorize your resources.
//
// Key is a required field
Key *string `min:"1" type:"string" required:"true"`
// The value for the specified tag key.
//
// Value is a required field
Value *string `type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s Tag) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s Tag) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *Tag) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "Tag"}
if s.Key == nil {
invalidParams.Add(request.NewErrParamRequired("Key"))
}
if s.Key != nil && len(*s.Key) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Key", 1))
}
if s.Value == nil {
invalidParams.Add(request.NewErrParamRequired("Value"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetKey sets the Key field's value.
func (s *Tag) SetKey(v string) *Tag {
s.Key = &v
return s
}
// SetValue sets the Value field's value.
func (s *Tag) SetValue(v string) *Tag {
s.Value = &v
return s
}
type TagResourceInput struct {
_ struct{} `type:"structure"`
// The ARN of the EventBridge resource that you're adding tags to.
//
// ResourceARN is a required field
ResourceARN *string `min:"1" type:"string" required:"true"`
// The list of key-value pairs to associate with the resource.
//
// Tags is a required field
Tags []*Tag `type:"list" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s TagResourceInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s TagResourceInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *TagResourceInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "TagResourceInput"}
if s.ResourceARN == nil {
invalidParams.Add(request.NewErrParamRequired("ResourceARN"))
}
if s.ResourceARN != nil && len(*s.ResourceARN) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ResourceARN", 1))
}
if s.Tags == nil {
invalidParams.Add(request.NewErrParamRequired("Tags"))
}
if s.Tags != nil {
for i, v := range s.Tags {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetResourceARN sets the ResourceARN field's value.
func (s *TagResourceInput) SetResourceARN(v string) *TagResourceInput {
s.ResourceARN = &v
return s
}
// SetTags sets the Tags field's value.
func (s *TagResourceInput) SetTags(v []*Tag) *TagResourceInput {
s.Tags = v
return s
}
type TagResourceOutput struct {
_ struct{} `type:"structure"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s TagResourceOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s TagResourceOutput) GoString() string {
return s.String()
}
// Targets are the resources to be invoked when a rule is triggered. For a complete
// list of services and resources that can be set as a target, see PutTargets
// (path_to_url
//
// If you are setting the event bus of another account as the target, and that
// account granted permission to your account through an organization instead
// of directly by the account ID, then you must specify a RoleArn with proper
// permissions in the Target structure. For more information, see Sending and
// Receiving Events Between Amazon Web Services Accounts (path_to_url
// in the Amazon EventBridge User Guide.
type Target struct {
_ struct{} `type:"structure"`
// The Amazon Resource Name (ARN) of the target.
//
// Arn is a required field
Arn *string `min:"1" type:"string" required:"true"`
// If the event target is an Batch job, this contains the job definition, job
// name, and other parameters. For more information, see Jobs (path_to_url
// in the Batch User Guide.
BatchParameters *BatchParameters `type:"structure"`
// The DeadLetterConfig that defines the target queue to send dead-letter queue
// events to.
DeadLetterConfig *DeadLetterConfig `type:"structure"`
// Contains the Amazon ECS task definition and task count to be used, if the
// event target is an Amazon ECS task. For more information about Amazon ECS
// tasks, see Task Definitions (path_to_url
// in the Amazon EC2 Container Service Developer Guide.
EcsParameters *EcsParameters `type:"structure"`
// Contains the HTTP parameters to use when the target is a API Gateway REST
// endpoint or EventBridge ApiDestination.
//
// If you specify an API Gateway REST API or EventBridge ApiDestination as a
// target, you can use this parameter to specify headers, path parameters, and
// query string keys/values as part of your target invoking request. If you're
// using ApiDestinations, the corresponding Connection can also have these values
// configured. In case of any conflicting keys, values from the Connection take
// precedence.
HttpParameters *HttpParameters `type:"structure"`
// The ID of the target. We recommend using a memorable and unique string.
//
// Id is a required field
Id *string `min:"1" type:"string" required:"true"`
// Valid JSON text passed to the target. In this case, nothing from the event
// itself is passed to the target. For more information, see The JavaScript
// Object Notation (JSON) Data Interchange Format (path_to_url
Input *string `type:"string"`
// The value of the JSONPath that is used for extracting part of the matched
// event when passing it to the target. You must use JSON dot notation, not
// bracket notation. For more information about JSON paths, see JSONPath (path_to_url
InputPath *string `type:"string"`
// Settings to enable you to provide custom input to a target based on certain
// event data. You can extract one or more key-value pairs from the event and
// then use that data to send customized input to the target.
InputTransformer *InputTransformer `type:"structure"`
// The custom parameter you can use to control the shard assignment, when the
// target is a Kinesis data stream. If you do not include this parameter, the
// default is to use the eventId as the partition key.
KinesisParameters *KinesisParameters `type:"structure"`
// Contains the Amazon Redshift Data API parameters to use when the target is
// a Amazon Redshift cluster.
//
// If you specify a Amazon Redshift Cluster as a Target, you can use this to
// specify parameters to invoke the Amazon Redshift Data API ExecuteStatement
// based on EventBridge events.
RedshiftDataParameters *RedshiftDataParameters `type:"structure"`
// The RetryPolicy object that contains the retry policy configuration to use
// for the dead-letter queue.
RetryPolicy *RetryPolicy `type:"structure"`
// The Amazon Resource Name (ARN) of the IAM role to be used for this target
// when the rule is triggered. If one rule triggers multiple targets, you can
// use a different IAM role for each target.
RoleArn *string `min:"1" type:"string"`
// Parameters used when you are using the rule to invoke Amazon EC2 Run Command.
RunCommandParameters *RunCommandParameters `type:"structure"`
// Contains the SageMaker Model Building Pipeline parameters to start execution
// of a SageMaker Model Building Pipeline.
//
// If you specify a SageMaker Model Building Pipeline as a target, you can use
// this to specify parameters to start a pipeline execution based on EventBridge
// events.
SageMakerPipelineParameters *SageMakerPipelineParameters `type:"structure"`
// Contains the message group ID to use when the target is a FIFO queue.
//
// If you specify an SQS FIFO queue as a target, the queue must have content-based
// deduplication enabled.
SqsParameters *SqsParameters `type:"structure"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s Target) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s Target) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *Target) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "Target"}
if s.Arn == nil {
invalidParams.Add(request.NewErrParamRequired("Arn"))
}
if s.Arn != nil && len(*s.Arn) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Arn", 1))
}
if s.Id == nil {
invalidParams.Add(request.NewErrParamRequired("Id"))
}
if s.Id != nil && len(*s.Id) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Id", 1))
}
if s.RoleArn != nil && len(*s.RoleArn) < 1 {
invalidParams.Add(request.NewErrParamMinLen("RoleArn", 1))
}
if s.BatchParameters != nil {
if err := s.BatchParameters.Validate(); err != nil {
invalidParams.AddNested("BatchParameters", err.(request.ErrInvalidParams))
}
}
if s.DeadLetterConfig != nil {
if err := s.DeadLetterConfig.Validate(); err != nil {
invalidParams.AddNested("DeadLetterConfig", err.(request.ErrInvalidParams))
}
}
if s.EcsParameters != nil {
if err := s.EcsParameters.Validate(); err != nil {
invalidParams.AddNested("EcsParameters", err.(request.ErrInvalidParams))
}
}
if s.InputTransformer != nil {
if err := s.InputTransformer.Validate(); err != nil {
invalidParams.AddNested("InputTransformer", err.(request.ErrInvalidParams))
}
}
if s.KinesisParameters != nil {
if err := s.KinesisParameters.Validate(); err != nil {
invalidParams.AddNested("KinesisParameters", err.(request.ErrInvalidParams))
}
}
if s.RedshiftDataParameters != nil {
if err := s.RedshiftDataParameters.Validate(); err != nil {
invalidParams.AddNested("RedshiftDataParameters", err.(request.ErrInvalidParams))
}
}
if s.RetryPolicy != nil {
if err := s.RetryPolicy.Validate(); err != nil {
invalidParams.AddNested("RetryPolicy", err.(request.ErrInvalidParams))
}
}
if s.RunCommandParameters != nil {
if err := s.RunCommandParameters.Validate(); err != nil {
invalidParams.AddNested("RunCommandParameters", err.(request.ErrInvalidParams))
}
}
if s.SageMakerPipelineParameters != nil {
if err := s.SageMakerPipelineParameters.Validate(); err != nil {
invalidParams.AddNested("SageMakerPipelineParameters", err.(request.ErrInvalidParams))
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetArn sets the Arn field's value.
func (s *Target) SetArn(v string) *Target {
s.Arn = &v
return s
}
// SetBatchParameters sets the BatchParameters field's value.
func (s *Target) SetBatchParameters(v *BatchParameters) *Target {
s.BatchParameters = v
return s
}
// SetDeadLetterConfig sets the DeadLetterConfig field's value.
func (s *Target) SetDeadLetterConfig(v *DeadLetterConfig) *Target {
s.DeadLetterConfig = v
return s
}
// SetEcsParameters sets the EcsParameters field's value.
func (s *Target) SetEcsParameters(v *EcsParameters) *Target {
s.EcsParameters = v
return s
}
// SetHttpParameters sets the HttpParameters field's value.
func (s *Target) SetHttpParameters(v *HttpParameters) *Target {
s.HttpParameters = v
return s
}
// SetId sets the Id field's value.
func (s *Target) SetId(v string) *Target {
s.Id = &v
return s
}
// SetInput sets the Input field's value.
func (s *Target) SetInput(v string) *Target {
s.Input = &v
return s
}
// SetInputPath sets the InputPath field's value.
func (s *Target) SetInputPath(v string) *Target {
s.InputPath = &v
return s
}
// SetInputTransformer sets the InputTransformer field's value.
func (s *Target) SetInputTransformer(v *InputTransformer) *Target {
s.InputTransformer = v
return s
}
// SetKinesisParameters sets the KinesisParameters field's value.
func (s *Target) SetKinesisParameters(v *KinesisParameters) *Target {
s.KinesisParameters = v
return s
}
// SetRedshiftDataParameters sets the RedshiftDataParameters field's value.
func (s *Target) SetRedshiftDataParameters(v *RedshiftDataParameters) *Target {
s.RedshiftDataParameters = v
return s
}
// SetRetryPolicy sets the RetryPolicy field's value.
func (s *Target) SetRetryPolicy(v *RetryPolicy) *Target {
s.RetryPolicy = v
return s
}
// SetRoleArn sets the RoleArn field's value.
func (s *Target) SetRoleArn(v string) *Target {
s.RoleArn = &v
return s
}
// SetRunCommandParameters sets the RunCommandParameters field's value.
func (s *Target) SetRunCommandParameters(v *RunCommandParameters) *Target {
s.RunCommandParameters = v
return s
}
// SetSageMakerPipelineParameters sets the SageMakerPipelineParameters field's value.
func (s *Target) SetSageMakerPipelineParameters(v *SageMakerPipelineParameters) *Target {
s.SageMakerPipelineParameters = v
return s
}
// SetSqsParameters sets the SqsParameters field's value.
func (s *Target) SetSqsParameters(v *SqsParameters) *Target {
s.SqsParameters = v
return s
}
type TestEventPatternInput struct {
_ struct{} `type:"structure"`
// The event, in JSON format, to test against the event pattern. The JSON must
// follow the format specified in Amazon Web Services Events (path_to_url
// and the following fields are mandatory:
//
// * id
//
// * account
//
// * source
//
// * time
//
// * region
//
// * resources
//
// * detail-type
//
// Event is a required field
Event *string `type:"string" required:"true"`
// The event pattern. For more information, see Events and Event Patterns (path_to_url
// in the Amazon EventBridge User Guide.
//
// EventPattern is a required field
EventPattern *string `type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s TestEventPatternInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s TestEventPatternInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *TestEventPatternInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "TestEventPatternInput"}
if s.Event == nil {
invalidParams.Add(request.NewErrParamRequired("Event"))
}
if s.EventPattern == nil {
invalidParams.Add(request.NewErrParamRequired("EventPattern"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetEvent sets the Event field's value.
func (s *TestEventPatternInput) SetEvent(v string) *TestEventPatternInput {
s.Event = &v
return s
}
// SetEventPattern sets the EventPattern field's value.
func (s *TestEventPatternInput) SetEventPattern(v string) *TestEventPatternInput {
s.EventPattern = &v
return s
}
type TestEventPatternOutput struct {
_ struct{} `type:"structure"`
// Indicates whether the event matches the event pattern.
Result *bool `type:"boolean"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s TestEventPatternOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s TestEventPatternOutput) GoString() string {
return s.String()
}
// SetResult sets the Result field's value.
func (s *TestEventPatternOutput) SetResult(v bool) *TestEventPatternOutput {
s.Result = &v
return s
}
type UntagResourceInput struct {
_ struct{} `type:"structure"`
// The ARN of the EventBridge resource from which you are removing tags.
//
// ResourceARN is a required field
ResourceARN *string `min:"1" type:"string" required:"true"`
// The list of tag keys to remove from the resource.
//
// TagKeys is a required field
TagKeys []*string `type:"list" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UntagResourceInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UntagResourceInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UntagResourceInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UntagResourceInput"}
if s.ResourceARN == nil {
invalidParams.Add(request.NewErrParamRequired("ResourceARN"))
}
if s.ResourceARN != nil && len(*s.ResourceARN) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ResourceARN", 1))
}
if s.TagKeys == nil {
invalidParams.Add(request.NewErrParamRequired("TagKeys"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetResourceARN sets the ResourceARN field's value.
func (s *UntagResourceInput) SetResourceARN(v string) *UntagResourceInput {
s.ResourceARN = &v
return s
}
// SetTagKeys sets the TagKeys field's value.
func (s *UntagResourceInput) SetTagKeys(v []*string) *UntagResourceInput {
s.TagKeys = v
return s
}
type UntagResourceOutput struct {
_ struct{} `type:"structure"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UntagResourceOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UntagResourceOutput) GoString() string {
return s.String()
}
type UpdateApiDestinationInput struct {
_ struct{} `type:"structure"`
// The ARN of the connection to use for the API destination.
ConnectionArn *string `min:"1" type:"string"`
// The name of the API destination to update.
Description *string `type:"string"`
// The method to use for the API destination.
HttpMethod *string `type:"string" enum:"ApiDestinationHttpMethod"`
// The URL to the endpoint to use for the API destination.
InvocationEndpoint *string `min:"1" type:"string"`
// The maximum number of invocations per second to send to the API destination.
InvocationRateLimitPerSecond *int64 `min:"1" type:"integer"`
// The name of the API destination to update.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UpdateApiDestinationInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UpdateApiDestinationInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateApiDestinationInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UpdateApiDestinationInput"}
if s.ConnectionArn != nil && len(*s.ConnectionArn) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ConnectionArn", 1))
}
if s.InvocationEndpoint != nil && len(*s.InvocationEndpoint) < 1 {
invalidParams.Add(request.NewErrParamMinLen("InvocationEndpoint", 1))
}
if s.InvocationRateLimitPerSecond != nil && *s.InvocationRateLimitPerSecond < 1 {
invalidParams.Add(request.NewErrParamMinValue("InvocationRateLimitPerSecond", 1))
}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetConnectionArn sets the ConnectionArn field's value.
func (s *UpdateApiDestinationInput) SetConnectionArn(v string) *UpdateApiDestinationInput {
s.ConnectionArn = &v
return s
}
// SetDescription sets the Description field's value.
func (s *UpdateApiDestinationInput) SetDescription(v string) *UpdateApiDestinationInput {
s.Description = &v
return s
}
// SetHttpMethod sets the HttpMethod field's value.
func (s *UpdateApiDestinationInput) SetHttpMethod(v string) *UpdateApiDestinationInput {
s.HttpMethod = &v
return s
}
// SetInvocationEndpoint sets the InvocationEndpoint field's value.
func (s *UpdateApiDestinationInput) SetInvocationEndpoint(v string) *UpdateApiDestinationInput {
s.InvocationEndpoint = &v
return s
}
// SetInvocationRateLimitPerSecond sets the InvocationRateLimitPerSecond field's value.
func (s *UpdateApiDestinationInput) SetInvocationRateLimitPerSecond(v int64) *UpdateApiDestinationInput {
s.InvocationRateLimitPerSecond = &v
return s
}
// SetName sets the Name field's value.
func (s *UpdateApiDestinationInput) SetName(v string) *UpdateApiDestinationInput {
s.Name = &v
return s
}
type UpdateApiDestinationOutput struct {
_ struct{} `type:"structure"`
// The ARN of the API destination that was updated.
ApiDestinationArn *string `min:"1" type:"string"`
// The state of the API destination that was updated.
ApiDestinationState *string `type:"string" enum:"ApiDestinationState"`
// A time stamp for the time that the API destination was created.
CreationTime *time.Time `type:"timestamp"`
// A time stamp for the time that the API destination was last modified.
LastModifiedTime *time.Time `type:"timestamp"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UpdateApiDestinationOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UpdateApiDestinationOutput) GoString() string {
return s.String()
}
// SetApiDestinationArn sets the ApiDestinationArn field's value.
func (s *UpdateApiDestinationOutput) SetApiDestinationArn(v string) *UpdateApiDestinationOutput {
s.ApiDestinationArn = &v
return s
}
// SetApiDestinationState sets the ApiDestinationState field's value.
func (s *UpdateApiDestinationOutput) SetApiDestinationState(v string) *UpdateApiDestinationOutput {
s.ApiDestinationState = &v
return s
}
// SetCreationTime sets the CreationTime field's value.
func (s *UpdateApiDestinationOutput) SetCreationTime(v time.Time) *UpdateApiDestinationOutput {
s.CreationTime = &v
return s
}
// SetLastModifiedTime sets the LastModifiedTime field's value.
func (s *UpdateApiDestinationOutput) SetLastModifiedTime(v time.Time) *UpdateApiDestinationOutput {
s.LastModifiedTime = &v
return s
}
type UpdateArchiveInput struct {
_ struct{} `type:"structure"`
// The name of the archive to update.
//
// ArchiveName is a required field
ArchiveName *string `min:"1" type:"string" required:"true"`
// The description for the archive.
Description *string `type:"string"`
// The event pattern to use to filter events sent to the archive.
EventPattern *string `type:"string"`
// The number of days to retain events in the archive.
RetentionDays *int64 `type:"integer"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UpdateArchiveInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UpdateArchiveInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateArchiveInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UpdateArchiveInput"}
if s.ArchiveName == nil {
invalidParams.Add(request.NewErrParamRequired("ArchiveName"))
}
if s.ArchiveName != nil && len(*s.ArchiveName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ArchiveName", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetArchiveName sets the ArchiveName field's value.
func (s *UpdateArchiveInput) SetArchiveName(v string) *UpdateArchiveInput {
s.ArchiveName = &v
return s
}
// SetDescription sets the Description field's value.
func (s *UpdateArchiveInput) SetDescription(v string) *UpdateArchiveInput {
s.Description = &v
return s
}
// SetEventPattern sets the EventPattern field's value.
func (s *UpdateArchiveInput) SetEventPattern(v string) *UpdateArchiveInput {
s.EventPattern = &v
return s
}
// SetRetentionDays sets the RetentionDays field's value.
func (s *UpdateArchiveInput) SetRetentionDays(v int64) *UpdateArchiveInput {
s.RetentionDays = &v
return s
}
type UpdateArchiveOutput struct {
_ struct{} `type:"structure"`
// The ARN of the archive.
ArchiveArn *string `min:"1" type:"string"`
// The time at which the archive was updated.
CreationTime *time.Time `type:"timestamp"`
// The state of the archive.
State *string `type:"string" enum:"ArchiveState"`
// The reason that the archive is in the current state.
StateReason *string `type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UpdateArchiveOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UpdateArchiveOutput) GoString() string {
return s.String()
}
// SetArchiveArn sets the ArchiveArn field's value.
func (s *UpdateArchiveOutput) SetArchiveArn(v string) *UpdateArchiveOutput {
s.ArchiveArn = &v
return s
}
// SetCreationTime sets the CreationTime field's value.
func (s *UpdateArchiveOutput) SetCreationTime(v time.Time) *UpdateArchiveOutput {
s.CreationTime = &v
return s
}
// SetState sets the State field's value.
func (s *UpdateArchiveOutput) SetState(v string) *UpdateArchiveOutput {
s.State = &v
return s
}
// SetStateReason sets the StateReason field's value.
func (s *UpdateArchiveOutput) SetStateReason(v string) *UpdateArchiveOutput {
s.StateReason = &v
return s
}
// Contains the API key authorization parameters to use to update the connection.
type UpdateConnectionApiKeyAuthRequestParameters struct {
_ struct{} `type:"structure"`
// The name of the API key to use for authorization.
ApiKeyName *string `min:"1" type:"string"`
// The value associated with teh API key to use for authorization.
//
// ApiKeyValue is a sensitive parameter and its value will be
// replaced with "sensitive" in string returned by UpdateConnectionApiKeyAuthRequestParameters's
// String and GoString methods.
ApiKeyValue *string `min:"1" type:"string" sensitive:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UpdateConnectionApiKeyAuthRequestParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UpdateConnectionApiKeyAuthRequestParameters) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateConnectionApiKeyAuthRequestParameters) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UpdateConnectionApiKeyAuthRequestParameters"}
if s.ApiKeyName != nil && len(*s.ApiKeyName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ApiKeyName", 1))
}
if s.ApiKeyValue != nil && len(*s.ApiKeyValue) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ApiKeyValue", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApiKeyName sets the ApiKeyName field's value.
func (s *UpdateConnectionApiKeyAuthRequestParameters) SetApiKeyName(v string) *UpdateConnectionApiKeyAuthRequestParameters {
s.ApiKeyName = &v
return s
}
// SetApiKeyValue sets the ApiKeyValue field's value.
func (s *UpdateConnectionApiKeyAuthRequestParameters) SetApiKeyValue(v string) *UpdateConnectionApiKeyAuthRequestParameters {
s.ApiKeyValue = &v
return s
}
// Contains the additional parameters to use for the connection.
type UpdateConnectionAuthRequestParameters struct {
_ struct{} `type:"structure"`
// A UpdateConnectionApiKeyAuthRequestParameters object that contains the authorization
// parameters for API key authorization.
ApiKeyAuthParameters *UpdateConnectionApiKeyAuthRequestParameters `type:"structure"`
// A UpdateConnectionBasicAuthRequestParameters object that contains the authorization
// parameters for Basic authorization.
BasicAuthParameters *UpdateConnectionBasicAuthRequestParameters `type:"structure"`
// A ConnectionHttpParameters object that contains the additional parameters
// to use for the connection.
InvocationHttpParameters *ConnectionHttpParameters `type:"structure"`
// A UpdateConnectionOAuthRequestParameters object that contains the authorization
// parameters for OAuth authorization.
OAuthParameters *UpdateConnectionOAuthRequestParameters `type:"structure"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UpdateConnectionAuthRequestParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UpdateConnectionAuthRequestParameters) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateConnectionAuthRequestParameters) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UpdateConnectionAuthRequestParameters"}
if s.ApiKeyAuthParameters != nil {
if err := s.ApiKeyAuthParameters.Validate(); err != nil {
invalidParams.AddNested("ApiKeyAuthParameters", err.(request.ErrInvalidParams))
}
}
if s.BasicAuthParameters != nil {
if err := s.BasicAuthParameters.Validate(); err != nil {
invalidParams.AddNested("BasicAuthParameters", err.(request.ErrInvalidParams))
}
}
if s.OAuthParameters != nil {
if err := s.OAuthParameters.Validate(); err != nil {
invalidParams.AddNested("OAuthParameters", err.(request.ErrInvalidParams))
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApiKeyAuthParameters sets the ApiKeyAuthParameters field's value.
func (s *UpdateConnectionAuthRequestParameters) SetApiKeyAuthParameters(v *UpdateConnectionApiKeyAuthRequestParameters) *UpdateConnectionAuthRequestParameters {
s.ApiKeyAuthParameters = v
return s
}
// SetBasicAuthParameters sets the BasicAuthParameters field's value.
func (s *UpdateConnectionAuthRequestParameters) SetBasicAuthParameters(v *UpdateConnectionBasicAuthRequestParameters) *UpdateConnectionAuthRequestParameters {
s.BasicAuthParameters = v
return s
}
// SetInvocationHttpParameters sets the InvocationHttpParameters field's value.
func (s *UpdateConnectionAuthRequestParameters) SetInvocationHttpParameters(v *ConnectionHttpParameters) *UpdateConnectionAuthRequestParameters {
s.InvocationHttpParameters = v
return s
}
// SetOAuthParameters sets the OAuthParameters field's value.
func (s *UpdateConnectionAuthRequestParameters) SetOAuthParameters(v *UpdateConnectionOAuthRequestParameters) *UpdateConnectionAuthRequestParameters {
s.OAuthParameters = v
return s
}
// Contains the Basic authorization parameters for the connection.
type UpdateConnectionBasicAuthRequestParameters struct {
_ struct{} `type:"structure"`
// The password associated with the user name to use for Basic authorization.
//
// Password is a sensitive parameter and its value will be
// replaced with "sensitive" in string returned by UpdateConnectionBasicAuthRequestParameters's
// String and GoString methods.
Password *string `min:"1" type:"string" sensitive:"true"`
// The user name to use for Basic authorization.
Username *string `min:"1" type:"string"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UpdateConnectionBasicAuthRequestParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UpdateConnectionBasicAuthRequestParameters) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateConnectionBasicAuthRequestParameters) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UpdateConnectionBasicAuthRequestParameters"}
if s.Password != nil && len(*s.Password) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Password", 1))
}
if s.Username != nil && len(*s.Username) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Username", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetPassword sets the Password field's value.
func (s *UpdateConnectionBasicAuthRequestParameters) SetPassword(v string) *UpdateConnectionBasicAuthRequestParameters {
s.Password = &v
return s
}
// SetUsername sets the Username field's value.
func (s *UpdateConnectionBasicAuthRequestParameters) SetUsername(v string) *UpdateConnectionBasicAuthRequestParameters {
s.Username = &v
return s
}
type UpdateConnectionInput struct {
_ struct{} `type:"structure"`
// The authorization parameters to use for the connection.
AuthParameters *UpdateConnectionAuthRequestParameters `type:"structure"`
// The type of authorization to use for the connection.
AuthorizationType *string `type:"string" enum:"ConnectionAuthorizationType"`
// A description for the connection.
Description *string `type:"string"`
// The name of the connection to update.
//
// Name is a required field
Name *string `min:"1" type:"string" required:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UpdateConnectionInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UpdateConnectionInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateConnectionInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UpdateConnectionInput"}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Name != nil && len(*s.Name) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Name", 1))
}
if s.AuthParameters != nil {
if err := s.AuthParameters.Validate(); err != nil {
invalidParams.AddNested("AuthParameters", err.(request.ErrInvalidParams))
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetAuthParameters sets the AuthParameters field's value.
func (s *UpdateConnectionInput) SetAuthParameters(v *UpdateConnectionAuthRequestParameters) *UpdateConnectionInput {
s.AuthParameters = v
return s
}
// SetAuthorizationType sets the AuthorizationType field's value.
func (s *UpdateConnectionInput) SetAuthorizationType(v string) *UpdateConnectionInput {
s.AuthorizationType = &v
return s
}
// SetDescription sets the Description field's value.
func (s *UpdateConnectionInput) SetDescription(v string) *UpdateConnectionInput {
s.Description = &v
return s
}
// SetName sets the Name field's value.
func (s *UpdateConnectionInput) SetName(v string) *UpdateConnectionInput {
s.Name = &v
return s
}
// Contains the OAuth authorization parameters to use for the connection.
type UpdateConnectionOAuthClientRequestParameters struct {
_ struct{} `type:"structure"`
// The client ID to use for OAuth authorization.
ClientID *string `min:"1" type:"string"`
// The client secret assciated with the client ID to use for OAuth authorization.
//
// ClientSecret is a sensitive parameter and its value will be
// replaced with "sensitive" in string returned by UpdateConnectionOAuthClientRequestParameters's
// String and GoString methods.
ClientSecret *string `min:"1" type:"string" sensitive:"true"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UpdateConnectionOAuthClientRequestParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UpdateConnectionOAuthClientRequestParameters) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateConnectionOAuthClientRequestParameters) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UpdateConnectionOAuthClientRequestParameters"}
if s.ClientID != nil && len(*s.ClientID) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ClientID", 1))
}
if s.ClientSecret != nil && len(*s.ClientSecret) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ClientSecret", 1))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetClientID sets the ClientID field's value.
func (s *UpdateConnectionOAuthClientRequestParameters) SetClientID(v string) *UpdateConnectionOAuthClientRequestParameters {
s.ClientID = &v
return s
}
// SetClientSecret sets the ClientSecret field's value.
func (s *UpdateConnectionOAuthClientRequestParameters) SetClientSecret(v string) *UpdateConnectionOAuthClientRequestParameters {
s.ClientSecret = &v
return s
}
// Contains the OAuth request parameters to use for the connection.
type UpdateConnectionOAuthRequestParameters struct {
_ struct{} `type:"structure"`
// The URL to the authorization endpoint when OAuth is specified as the authorization
// type.
AuthorizationEndpoint *string `min:"1" type:"string"`
// A UpdateConnectionOAuthClientRequestParameters object that contains the client
// parameters to use for the connection when OAuth is specified as the authorization
// type.
ClientParameters *UpdateConnectionOAuthClientRequestParameters `type:"structure"`
// The method used to connect to the HTTP endpoint.
HttpMethod *string `type:"string" enum:"ConnectionOAuthHttpMethod"`
// The additional HTTP parameters used for the OAuth authorization request.
OAuthHttpParameters *ConnectionHttpParameters `type:"structure"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UpdateConnectionOAuthRequestParameters) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UpdateConnectionOAuthRequestParameters) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateConnectionOAuthRequestParameters) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UpdateConnectionOAuthRequestParameters"}
if s.AuthorizationEndpoint != nil && len(*s.AuthorizationEndpoint) < 1 {
invalidParams.Add(request.NewErrParamMinLen("AuthorizationEndpoint", 1))
}
if s.ClientParameters != nil {
if err := s.ClientParameters.Validate(); err != nil {
invalidParams.AddNested("ClientParameters", err.(request.ErrInvalidParams))
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetAuthorizationEndpoint sets the AuthorizationEndpoint field's value.
func (s *UpdateConnectionOAuthRequestParameters) SetAuthorizationEndpoint(v string) *UpdateConnectionOAuthRequestParameters {
s.AuthorizationEndpoint = &v
return s
}
// SetClientParameters sets the ClientParameters field's value.
func (s *UpdateConnectionOAuthRequestParameters) SetClientParameters(v *UpdateConnectionOAuthClientRequestParameters) *UpdateConnectionOAuthRequestParameters {
s.ClientParameters = v
return s
}
// SetHttpMethod sets the HttpMethod field's value.
func (s *UpdateConnectionOAuthRequestParameters) SetHttpMethod(v string) *UpdateConnectionOAuthRequestParameters {
s.HttpMethod = &v
return s
}
// SetOAuthHttpParameters sets the OAuthHttpParameters field's value.
func (s *UpdateConnectionOAuthRequestParameters) SetOAuthHttpParameters(v *ConnectionHttpParameters) *UpdateConnectionOAuthRequestParameters {
s.OAuthHttpParameters = v
return s
}
type UpdateConnectionOutput struct {
_ struct{} `type:"structure"`
// The ARN of the connection that was updated.
ConnectionArn *string `min:"1" type:"string"`
// The state of the connection that was updated.
ConnectionState *string `type:"string" enum:"ConnectionState"`
// A time stamp for the time that the connection was created.
CreationTime *time.Time `type:"timestamp"`
// A time stamp for the time that the connection was last authorized.
LastAuthorizedTime *time.Time `type:"timestamp"`
// A time stamp for the time that the connection was last modified.
LastModifiedTime *time.Time `type:"timestamp"`
}
// String returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UpdateConnectionOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation.
//
// API parameter values that are decorated as "sensitive" in the API will not
// be included in the string output. The member name will be present, but the
// value will be replaced with "sensitive".
func (s UpdateConnectionOutput) GoString() string {
return s.String()
}
// SetConnectionArn sets the ConnectionArn field's value.
func (s *UpdateConnectionOutput) SetConnectionArn(v string) *UpdateConnectionOutput {
s.ConnectionArn = &v
return s
}
// SetConnectionState sets the ConnectionState field's value.
func (s *UpdateConnectionOutput) SetConnectionState(v string) *UpdateConnectionOutput {
s.ConnectionState = &v
return s
}
// SetCreationTime sets the CreationTime field's value.
func (s *UpdateConnectionOutput) SetCreationTime(v time.Time) *UpdateConnectionOutput {
s.CreationTime = &v
return s
}
// SetLastAuthorizedTime sets the LastAuthorizedTime field's value.
func (s *UpdateConnectionOutput) SetLastAuthorizedTime(v time.Time) *UpdateConnectionOutput {
s.LastAuthorizedTime = &v
return s
}
// SetLastModifiedTime sets the LastModifiedTime field's value.
func (s *UpdateConnectionOutput) SetLastModifiedTime(v time.Time) *UpdateConnectionOutput {
s.LastModifiedTime = &v
return s
}
const (
// ApiDestinationHttpMethodPost is a ApiDestinationHttpMethod enum value
ApiDestinationHttpMethodPost = "POST"
// ApiDestinationHttpMethodGet is a ApiDestinationHttpMethod enum value
ApiDestinationHttpMethodGet = "GET"
// ApiDestinationHttpMethodHead is a ApiDestinationHttpMethod enum value
ApiDestinationHttpMethodHead = "HEAD"
// ApiDestinationHttpMethodOptions is a ApiDestinationHttpMethod enum value
ApiDestinationHttpMethodOptions = "OPTIONS"
// ApiDestinationHttpMethodPut is a ApiDestinationHttpMethod enum value
ApiDestinationHttpMethodPut = "PUT"
// ApiDestinationHttpMethodPatch is a ApiDestinationHttpMethod enum value
ApiDestinationHttpMethodPatch = "PATCH"
// ApiDestinationHttpMethodDelete is a ApiDestinationHttpMethod enum value
ApiDestinationHttpMethodDelete = "DELETE"
)
// ApiDestinationHttpMethod_Values returns all elements of the ApiDestinationHttpMethod enum
func ApiDestinationHttpMethod_Values() []string {
return []string{
ApiDestinationHttpMethodPost,
ApiDestinationHttpMethodGet,
ApiDestinationHttpMethodHead,
ApiDestinationHttpMethodOptions,
ApiDestinationHttpMethodPut,
ApiDestinationHttpMethodPatch,
ApiDestinationHttpMethodDelete,
}
}
const (
// ApiDestinationStateActive is a ApiDestinationState enum value
ApiDestinationStateActive = "ACTIVE"
// ApiDestinationStateInactive is a ApiDestinationState enum value
ApiDestinationStateInactive = "INACTIVE"
)
// ApiDestinationState_Values returns all elements of the ApiDestinationState enum
func ApiDestinationState_Values() []string {
return []string{
ApiDestinationStateActive,
ApiDestinationStateInactive,
}
}
const (
// ArchiveStateEnabled is a ArchiveState enum value
ArchiveStateEnabled = "ENABLED"
// ArchiveStateDisabled is a ArchiveState enum value
ArchiveStateDisabled = "DISABLED"
// ArchiveStateCreating is a ArchiveState enum value
ArchiveStateCreating = "CREATING"
// ArchiveStateUpdating is a ArchiveState enum value
ArchiveStateUpdating = "UPDATING"
// ArchiveStateCreateFailed is a ArchiveState enum value
ArchiveStateCreateFailed = "CREATE_FAILED"
// ArchiveStateUpdateFailed is a ArchiveState enum value
ArchiveStateUpdateFailed = "UPDATE_FAILED"
)
// ArchiveState_Values returns all elements of the ArchiveState enum
func ArchiveState_Values() []string {
return []string{
ArchiveStateEnabled,
ArchiveStateDisabled,
ArchiveStateCreating,
ArchiveStateUpdating,
ArchiveStateCreateFailed,
ArchiveStateUpdateFailed,
}
}
const (
// AssignPublicIpEnabled is a AssignPublicIp enum value
AssignPublicIpEnabled = "ENABLED"
// AssignPublicIpDisabled is a AssignPublicIp enum value
AssignPublicIpDisabled = "DISABLED"
)
// AssignPublicIp_Values returns all elements of the AssignPublicIp enum
func AssignPublicIp_Values() []string {
return []string{
AssignPublicIpEnabled,
AssignPublicIpDisabled,
}
}
const (
// ConnectionAuthorizationTypeBasic is a ConnectionAuthorizationType enum value
ConnectionAuthorizationTypeBasic = "BASIC"
// ConnectionAuthorizationTypeOauthClientCredentials is a ConnectionAuthorizationType enum value
ConnectionAuthorizationTypeOauthClientCredentials = "OAUTH_CLIENT_CREDENTIALS"
// ConnectionAuthorizationTypeApiKey is a ConnectionAuthorizationType enum value
ConnectionAuthorizationTypeApiKey = "API_KEY"
)
// ConnectionAuthorizationType_Values returns all elements of the ConnectionAuthorizationType enum
func ConnectionAuthorizationType_Values() []string {
return []string{
ConnectionAuthorizationTypeBasic,
ConnectionAuthorizationTypeOauthClientCredentials,
ConnectionAuthorizationTypeApiKey,
}
}
const (
// ConnectionOAuthHttpMethodGet is a ConnectionOAuthHttpMethod enum value
ConnectionOAuthHttpMethodGet = "GET"
// ConnectionOAuthHttpMethodPost is a ConnectionOAuthHttpMethod enum value
ConnectionOAuthHttpMethodPost = "POST"
// ConnectionOAuthHttpMethodPut is a ConnectionOAuthHttpMethod enum value
ConnectionOAuthHttpMethodPut = "PUT"
)
// ConnectionOAuthHttpMethod_Values returns all elements of the ConnectionOAuthHttpMethod enum
func ConnectionOAuthHttpMethod_Values() []string {
return []string{
ConnectionOAuthHttpMethodGet,
ConnectionOAuthHttpMethodPost,
ConnectionOAuthHttpMethodPut,
}
}
const (
// ConnectionStateCreating is a ConnectionState enum value
ConnectionStateCreating = "CREATING"
// ConnectionStateUpdating is a ConnectionState enum value
ConnectionStateUpdating = "UPDATING"
// ConnectionStateDeleting is a ConnectionState enum value
ConnectionStateDeleting = "DELETING"
// ConnectionStateAuthorized is a ConnectionState enum value
ConnectionStateAuthorized = "AUTHORIZED"
// ConnectionStateDeauthorized is a ConnectionState enum value
ConnectionStateDeauthorized = "DEAUTHORIZED"
// ConnectionStateAuthorizing is a ConnectionState enum value
ConnectionStateAuthorizing = "AUTHORIZING"
// ConnectionStateDeauthorizing is a ConnectionState enum value
ConnectionStateDeauthorizing = "DEAUTHORIZING"
)
// ConnectionState_Values returns all elements of the ConnectionState enum
func ConnectionState_Values() []string {
return []string{
ConnectionStateCreating,
ConnectionStateUpdating,
ConnectionStateDeleting,
ConnectionStateAuthorized,
ConnectionStateDeauthorized,
ConnectionStateAuthorizing,
ConnectionStateDeauthorizing,
}
}
const (
// EventSourceStatePending is a EventSourceState enum value
EventSourceStatePending = "PENDING"
// EventSourceStateActive is a EventSourceState enum value
EventSourceStateActive = "ACTIVE"
// EventSourceStateDeleted is a EventSourceState enum value
EventSourceStateDeleted = "DELETED"
)
// EventSourceState_Values returns all elements of the EventSourceState enum
func EventSourceState_Values() []string {
return []string{
EventSourceStatePending,
EventSourceStateActive,
EventSourceStateDeleted,
}
}
const (
// LaunchTypeEc2 is a LaunchType enum value
LaunchTypeEc2 = "EC2"
// LaunchTypeFargate is a LaunchType enum value
LaunchTypeFargate = "FARGATE"
// LaunchTypeExternal is a LaunchType enum value
LaunchTypeExternal = "EXTERNAL"
)
// LaunchType_Values returns all elements of the LaunchType enum
func LaunchType_Values() []string {
return []string{
LaunchTypeEc2,
LaunchTypeFargate,
LaunchTypeExternal,
}
}
const (
// PlacementConstraintTypeDistinctInstance is a PlacementConstraintType enum value
PlacementConstraintTypeDistinctInstance = "distinctInstance"
// PlacementConstraintTypeMemberOf is a PlacementConstraintType enum value
PlacementConstraintTypeMemberOf = "memberOf"
)
// PlacementConstraintType_Values returns all elements of the PlacementConstraintType enum
func PlacementConstraintType_Values() []string {
return []string{
PlacementConstraintTypeDistinctInstance,
PlacementConstraintTypeMemberOf,
}
}
const (
// PlacementStrategyTypeRandom is a PlacementStrategyType enum value
PlacementStrategyTypeRandom = "random"
// PlacementStrategyTypeSpread is a PlacementStrategyType enum value
PlacementStrategyTypeSpread = "spread"
// PlacementStrategyTypeBinpack is a PlacementStrategyType enum value
PlacementStrategyTypeBinpack = "binpack"
)
// PlacementStrategyType_Values returns all elements of the PlacementStrategyType enum
func PlacementStrategyType_Values() []string {
return []string{
PlacementStrategyTypeRandom,
PlacementStrategyTypeSpread,
PlacementStrategyTypeBinpack,
}
}
const (
// PropagateTagsTaskDefinition is a PropagateTags enum value
PropagateTagsTaskDefinition = "TASK_DEFINITION"
)
// PropagateTags_Values returns all elements of the PropagateTags enum
func PropagateTags_Values() []string {
return []string{
PropagateTagsTaskDefinition,
}
}
const (
// ReplayStateStarting is a ReplayState enum value
ReplayStateStarting = "STARTING"
// ReplayStateRunning is a ReplayState enum value
ReplayStateRunning = "RUNNING"
// ReplayStateCancelling is a ReplayState enum value
ReplayStateCancelling = "CANCELLING"
// ReplayStateCompleted is a ReplayState enum value
ReplayStateCompleted = "COMPLETED"
// ReplayStateCancelled is a ReplayState enum value
ReplayStateCancelled = "CANCELLED"
// ReplayStateFailed is a ReplayState enum value
ReplayStateFailed = "FAILED"
)
// ReplayState_Values returns all elements of the ReplayState enum
func ReplayState_Values() []string {
return []string{
ReplayStateStarting,
ReplayStateRunning,
ReplayStateCancelling,
ReplayStateCompleted,
ReplayStateCancelled,
ReplayStateFailed,
}
}
const (
// RuleStateEnabled is a RuleState enum value
RuleStateEnabled = "ENABLED"
// RuleStateDisabled is a RuleState enum value
RuleStateDisabled = "DISABLED"
)
// RuleState_Values returns all elements of the RuleState enum
func RuleState_Values() []string {
return []string{
RuleStateEnabled,
RuleStateDisabled,
}
}
```
|
Upton Site may refer to:
Upton Site, an archaeological site listed on the National Register of Historic Places near Deming, New Mexico
Archeological Site 38CK1, an archaeological site listed on the National Register of Historic Places also known as Upton Site near Gaffney, South Carolina
|
```go
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
package searcher
import (
"testing"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
"github.com/m3db/m3/src/m3ninx/index"
"github.com/m3db/m3/src/m3ninx/postings"
"github.com/m3db/m3/src/m3ninx/postings/roaring"
"github.com/m3db/m3/src/m3ninx/search"
)
func TestConjunctionSearcher(t *testing.T) {
mockCtrl := gomock.NewController(t)
defer mockCtrl.Finish()
firstReader := index.NewMockReader(mockCtrl)
secondReader := index.NewMockReader(mockCtrl)
// First searcher.
firstPL1 := roaring.NewPostingsList()
require.NoError(t, firstPL1.Insert(postings.ID(42)))
require.NoError(t, firstPL1.Insert(postings.ID(50)))
firstPL2 := roaring.NewPostingsList()
require.NoError(t, firstPL2.Insert(postings.ID(64)))
firstSearcher := search.NewMockSearcher(mockCtrl)
// Second searcher.
secondPL1 := roaring.NewPostingsList()
require.NoError(t, secondPL1.Insert(postings.ID(53)))
require.NoError(t, secondPL1.Insert(postings.ID(50)))
secondPL2 := roaring.NewPostingsList()
require.NoError(t, secondPL2.Insert(postings.ID(64)))
require.NoError(t, secondPL2.Insert(postings.ID(72)))
secondSearcher := search.NewMockSearcher(mockCtrl)
// Third searcher.
thirdPL1 := roaring.NewPostingsList()
require.NoError(t, thirdPL1.Insert(postings.ID(42)))
require.NoError(t, thirdPL1.Insert(postings.ID(53)))
thirdPL2 := roaring.NewPostingsList()
require.NoError(t, thirdPL2.Insert(postings.ID(64)))
require.NoError(t, thirdPL2.Insert(postings.ID(89)))
thirdSearcher := search.NewMockSearcher(mockCtrl)
gomock.InOrder(
// Get the postings lists for the first Reader.
firstSearcher.EXPECT().Search(firstReader).Return(firstPL1, nil),
secondSearcher.EXPECT().Search(firstReader).Return(secondPL1, nil),
thirdSearcher.EXPECT().Search(firstReader).Return(thirdPL1, nil),
// Get the postings lists for the second Reader.
firstSearcher.EXPECT().Search(secondReader).Return(firstPL2, nil),
secondSearcher.EXPECT().Search(secondReader).Return(secondPL2, nil),
thirdSearcher.EXPECT().Search(secondReader).Return(thirdPL2, nil),
)
var (
searchers = []search.Searcher{firstSearcher, secondSearcher}
negations = []search.Searcher{thirdSearcher}
)
s, err := NewConjunctionSearcher(searchers, negations)
require.NoError(t, err)
// Test the postings list from the first Reader.
var expected postings.List = firstPL1
expected, err = expected.Intersect(secondPL1)
require.NoError(t, err)
expected, err = expected.Difference(thirdPL1)
require.NoError(t, err)
pl, err := s.Search(firstReader)
require.NoError(t, err)
require.True(t, pl.Equal(expected))
// Test the postings list from the second Reader.
expected = firstPL2
expected, err = expected.Intersect(secondPL2)
require.NoError(t, err)
expected, err = expected.Difference(thirdPL2)
require.NoError(t, err)
pl, err = s.Search(secondReader)
require.NoError(t, err)
require.True(t, pl.Equal(expected))
}
func TestConjunctionSearcherError(t *testing.T) {
tests := []struct {
name string
searchers search.Searchers
negations search.Searchers
}{
{
name: "empty list of searchers",
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
_, err := NewConjunctionSearcher(test.searchers, test.negations)
require.Error(t, err)
})
}
}
```
|
```java
/*
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ddl;
import lombok.Getter;
import lombok.Setter;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.segment.impl.table.ExpectedSimpleTable;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.SQLParserTestCase;
import javax.xml.bind.annotation.XmlElement;
/**
* Flashback table statement test case.
*/
@Getter
@Setter
public final class FlashbackTableStatementTestCase extends SQLParserTestCase {
@XmlElement
private ExpectedSimpleTable table;
@XmlElement(name = "rename-table")
private ExpectedSimpleTable renameTable;
}
```
|
```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title></title>
<link rel="stylesheet" href="./style.css">
</head>
<body>
<div id="app"></div>
<script src="../dist/yox.js"></script>
<script>
let Custom = {
propTypes: {
name: {
type: ['string', 'number'],
value: 'musicode',
},
counter: {
type: 'number',
value: 0,
}
},
template: `
<div id="custom-component">
{{name}} -> {{counter}}
</div>
`
};
var instance = new Yox({
el: '#app',
data: {
name: 1,
counter: 1,
},
template: `
<div id="root">
<button on-click="increase('counter')">
increase
</button>
<Custom name="{{name}}" counter="{{counter}}" />
</div>
`,
watchers: {
counter: function (counter) {
console.log(counter)
}
},
components: {
Custom: Custom
},
});
</script>
</body>
</html>
```
|
Epic Astro Story is a simulation video game developed and published by Kairosoft for the Android and iOS operating systems. It was released in December, 2011 for Android and in April, 2012 for iOS. The player is tasked with managing and expanding a colony in a science fiction setting, while also exploring both their colony and other planets. The game has received mostly positive reviews from critics.
Gameplay
Epic Astro Story has two main facets to its gameplay. The first is a city managing simulation, where the player is required to build up a colony and build its success. The second is a colony exploration component, which allows the player to look through caves, empty territory, and other planets for loot and land, and contains a battle system where the colony's explorers must fight aliens and monsters. As the teams of colonists leave to explore, their progress in different areas is tracked through a bar on the bottom of the screen, which allows the player to continue with other management issues while the explorers continue their work. All of the colonists have names that are a play on popular Star Trek characters.
Reception
Epic Astro Story has received mostly positive reviews from critics, with the iOS version receiving a 91/100 from review aggregator website Metacritic. TouchArcade Colette Bennett called the iOS version her favorite title of Kairosoft's release thus far, and felt that the battle system broke up the company's formula for past management simulation games. Pocket Gamer Damien McFarren was impressed by the Android version's surprisingly "multifaceted gameplay", and praised its addictive formula. Gamezebo's Kevin Alexander, in his review of the Android version, felt that the game did a good job presenting a number of different factors in a fun and easy to manage way.
References
2011 video games
Android (operating system) games
IOS games
Kairosoft games
Single-player video games
Video games developed in Japan
|
Place Versailles is a shopping mall located at the corner of Sherbrooke Street East and Highway 25 in the Mercier–Hochelaga-Maisonneuve borough of Montreal, Quebec, Canada. With its 225 stores, it is the largest enclosed shopping centre on the Island of Montreal. Its anchors are Canadian Tire, Maxi, Winners/HomeSense and Bureau en Gros.
Most of the mall is one storey high, but a section of the mall, which was added in the 1980s, has two floors. Place Versailles is situated next to the Radisson metro station and is less than 2 km south of the Galeries d'Anjou mall.
History
Place Versailles officially opened on November 7, 1963 with 30 stores. Upon its opening, Place Versailles was the first enclosed shopping mall in the Montreal area. Its 30 stores included Steinberg, Miracle Mart and Greenberg. There was also in the parking the Cinema Versailles with its two theatres, one for English films and the other for French ones. The stores of Place Versailles totalized 350,000 square feet and the land of the complex was 2,000,000 square foot. Today, the original section of Place Versailles can be recognized as the corridor of Canadian Tire and Maxi.
Pascal's opened a new store on August 21, 1969. At 91,000 square feet, it was the largest of Pascal's stores and one of the biggest locations of any hardware outlet built at the time.
On March 15, 1973, the Hudson's Bay Company opened a The Bay department store of 134,500 square feet.
From 1973 to 1987, Place Versailles was anchored by The Bay, Miracle Mart, Steinberg and Pascal's.
Miracle Mart at Place Versailles was rebranded under the M brand name on August 19, 1987; one of the last stores in Montreal to transition to the new nameplate.
In the late 1980s, Place Versailles expanded again and a new section was built with two floors, instead of one floor as in the rest of the mall.
On May 16, 1991, the Pascal's hardware chain went bankrupt. The store at Place Versailles closed at the end of July 1991. Except for three other locations, the vast majority of the Pascal's chain had already shuttered by the time the Place Versailles store closed.
Fabricville opened its current store May 13, 1992.
Following the bankruptcy and liquidation of the M retain chain in June 1992, the Place Versailles store was closed on August 29, 1992. Mirroring what had happened to Pascal's a year before, the M store at Place Versailles was among the last four locations to close chainwide. Also in 1992, Steinberg was converted to Maxi. From then on and until about 2003, Place Versailles was anchored by The Bay, Maxi, Zellers and Rona - Le Quincailler.
Hudson's Bay Company closed its The Bay store at Place Versailles during the last quarter of 2003. The Bay's anchor space has since been dismantled by Winners/Homesense, Globo, Style Exchange (today Urban Depot), Safari, Sports Experts, Dollarama and McDonald's.
Rona closed in 2005 and Bureau en Gros took its space a year later.
Popular Quebec sports-themed restaurant chain La Cage aux Sports (later renamed La Cage – Brasserie sportive) opened its 50th restaurant in history at the mall in 2010, on the mall’s second floor. The restaurant can also be accessed from the outside of the mall via an elevator connecting the parking lot to the restaurant. The first sporting events shown at the restaurant were an NHL hockey game between the Montreal Canadiens and the Ottawa Senators, followed by the martial arts event UFC 121, whose main card was highlighted with a clash between Brock Lesnar and Cain Velasquez. During the 2015 FIFA Women’s World Cup tournament in which Canada was the host nation, the La Cage of the mall was featured on Fox Sports’ Garbage Time with Katie Nolan as a popular sports bar for U.S. soccer fans.
Zellers closed its doors in 2012 and was replaced by Target on September 17, 2013. Target did not want the former Zellers entrance that connected directly to Place Versailles' food court and, as a result, it was replaced by a graphic water fountain that the mall claims on its website to be the first in North America. Target closed in 2015 and lease sold to Canadian Tire in May 2015.
2017 Santa Claus incident
In 2017, the mall faced criticism for promoting their Santa Claus' arrival to be on November 11, which is when Remembrance Day is observed in Canada. Furthermore, their Santa would be arriving at 10 a.m., one hour before the 11 a.m. Remembrance Day ceremonies would take place in Ottawa. Local veterans were quick to shun the mall for their decision, claiming that it showed a "lack of respect" towards Canadian veterans, especially given that 2017 marked the 100th anniversary of the Battle of Passchendaele, a key battle that took place during World War I. Requests were made for the mall to reschedule Santa's arrival, with some also asking to delay his arrival until once the ceremonies have concluded, but the mall kept his arrival date and time unchanged. Their Santa Claus was scheduled to make his entrance via helicopter and due to logistical concerns beyond the mall's control, his arrival could not be rescheduled to a different day. The mall did however try to make amends to the veterans over this issue in a Facebook post that has since been deleted and apologized for their decision.
See also
Galeries d'Anjou
List of largest shopping malls in Canada
List of shopping malls in Montreal
References
External links
Shopping malls established in 1963
Shopping malls in Montreal
Mercier–Hochelaga-Maisonneuve
|
The 1892 Centre football team represented Centre College as an independent during the 1892 college football season. Led by second-year head coach W. Durant Berry, Centre compiled a record of 6–0.
Schedule
References
Centre
Centre Colonels football seasons
College football undefeated seasons
Centre football
|
Khan Kluay (; ; ) is a Thai computer-animated feature film franchise set during Ayutthaya-era Siam about an elephant who wanders away from his mother and eventually becomes the war elephant for King Naresuan. It is based on "Chao Praya Prab Hongsawadee" by Ariya Jintapanichkarn. A PC game called Khankluay:The Adventure has also been released in Thailand.
It was officially released as Jumbo in India and The Blue Elephant in the United States.
by 2018, elefantsya was only released in Ukraine and not in the Former Soviet Union & Russia.
Characters and Cast
Thai animation
Fictional elephants
Animation franchises
Thai film series
|
```python
# THIS FILE IS AUTO-GENERATED. DO NOT EDIT
from verta._swagger.base_type import BaseType
class ModeldbUpdateComment(BaseType):
def __init__(self, id=None, entity_id=None, date_time=None, message=None):
required = {
"id": False,
"entity_id": False,
"date_time": False,
"message": False,
}
self.id = id
self.entity_id = entity_id
self.date_time = date_time
self.message = message
for k, v in required.items():
if self[k] is None and v:
raise ValueError('attribute {} is required'.format(k))
@staticmethod
def from_json(d):
tmp = d.get('id', None)
if tmp is not None:
d['id'] = tmp
tmp = d.get('entity_id', None)
if tmp is not None:
d['entity_id'] = tmp
tmp = d.get('date_time', None)
if tmp is not None:
d['date_time'] = tmp
tmp = d.get('message', None)
if tmp is not None:
d['message'] = tmp
return ModeldbUpdateComment(**d)
```
|
```shell
#!/usr/bin/env bash
CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
# shellcheck source=../shell_config.sh
. "$CURDIR"/../shell_config.sh
# shellcheck source=./mergetree_mutations.lib
. "$CURDIR"/mergetree_mutations.lib
${CLICKHOUSE_CLIENT} --query="DROP TABLE IF EXISTS table_with_empty_part"
${CLICKHOUSE_CLIENT} --query="CREATE TABLE table_with_empty_part
(
id UInt64,
value UInt64
)
ENGINE = MergeTree()
ORDER BY id
PARTITION BY id
SETTINGS vertical_merge_algorithm_min_rows_to_activate=0, vertical_merge_algorithm_min_columns_to_activate=0, remove_empty_parts = 0, min_bytes_for_wide_part=0, min_bytes_for_full_part_storage = 0
"
${CLICKHOUSE_CLIENT} --query="INSERT INTO table_with_empty_part VALUES (1, 1)"
${CLICKHOUSE_CLIENT} --query="INSERT INTO table_with_empty_part VALUES (2, 2)"
${CLICKHOUSE_CLIENT} --mutations_sync=2 --query="ALTER TABLE table_with_empty_part DELETE WHERE id % 2 == 0"
${CLICKHOUSE_CLIENT} --query="SELECT COUNT(DISTINCT value) FROM table_with_empty_part"
${CLICKHOUSE_CLIENT} --query="ALTER TABLE table_with_empty_part MODIFY COLUMN value Nullable(UInt64)"
${CLICKHOUSE_CLIENT} --query="SELECT COUNT(distinct value) FROM table_with_empty_part"
${CLICKHOUSE_CLIENT} --query="OPTIMIZE TABLE table_with_empty_part FINAL"
${CLICKHOUSE_CLIENT} --query="DROP TABLE IF EXISTS table_with_empty_part"
```
|
Women's freestyle 50 kilograms competition at the 2020 Summer Olympics in Tokyo, Japan, took place on 6–7 August 2021 at the Makuhari Messe in Mihama-ku.
This freestyle wrestling competition consists of a single-elimination tournament, with a repechage used to determine the winner of two bronze medals. The two finalists face off for gold and silver medals. Each wrestler who loses to one of the two finalists moves into the repechage, culminating in a pair of bronze medal matches featuring the semifinal losers each facing the remaining repechage opponent from their half of the bracket.
Schedule
All times are Japan Standard Time (UTC+9:00)
Results
Legend
F — Won by fall
WO — Won by walkover
Main bracket
Repechage
Final standing
References
Wrestling at the 2020 Summer Olympics
Women's events at the 2020 Summer Olympics
2021 in women's sport wrestling
|
"El baile del gorila" is the debut single by Spanish singer Melody, taken from her debut album De pata negra. She released it in 2001, at the age of 10.
The song debuted at number 2 in Spain for the week of 7 July 2001, climbing to number one two weeks later. It was the dance hit of that summer in Spain.
Track listing
Charts
Weekly charts
Year-end charts
Certifications
References
External links
2001 songs
2001 debut singles
Melody (Spanish singer) songs
Epic Records singles
|
```go
// Code generated by test DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***
package different
import (
"context"
"reflect"
"errors"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
"simple-plain-schema-with-root-package/internal"
)
type Component struct {
pulumi.ResourceState
A pulumi.BoolOutput `pulumi:"a"`
B pulumi.BoolPtrOutput `pulumi:"b"`
Bar FooPtrOutput `pulumi:"bar"`
Baz FooArrayOutput `pulumi:"baz"`
C pulumi.IntOutput `pulumi:"c"`
D pulumi.IntPtrOutput `pulumi:"d"`
E pulumi.StringOutput `pulumi:"e"`
F pulumi.StringPtrOutput `pulumi:"f"`
Foo FooPtrOutput `pulumi:"foo"`
}
// NewComponent registers a new resource with the given unique name, arguments, and options.
func NewComponent(ctx *pulumi.Context,
name string, args *ComponentArgs, opts ...pulumi.ResourceOption) (*Component, error) {
if args == nil {
return nil, errors.New("missing one or more required arguments")
}
opts = internal.PkgResourceDefaultOpts(opts)
var resource Component
err := ctx.RegisterRemoteComponentResource("example::Component", name, args, &resource, opts...)
if err != nil {
return nil, err
}
return &resource, nil
}
type componentArgs struct {
A bool `pulumi:"a"`
B *bool `pulumi:"b"`
Bar *Foo `pulumi:"bar"`
Baz []Foo `pulumi:"baz"`
C int `pulumi:"c"`
D *int `pulumi:"d"`
E string `pulumi:"e"`
F *string `pulumi:"f"`
Foo *Foo `pulumi:"foo"`
}
// The set of arguments for constructing a Component resource.
type ComponentArgs struct {
A bool
B *bool
Bar *FooArgs
Baz []FooInput
C int
D *int
E string
F *string
Foo FooPtrInput
}
func (ComponentArgs) ElementType() reflect.Type {
return reflect.TypeOf((*componentArgs)(nil)).Elem()
}
type ComponentInput interface {
pulumi.Input
ToComponentOutput() ComponentOutput
ToComponentOutputWithContext(ctx context.Context) ComponentOutput
}
func (*Component) ElementType() reflect.Type {
return reflect.TypeOf((**Component)(nil)).Elem()
}
func (i *Component) ToComponentOutput() ComponentOutput {
return i.ToComponentOutputWithContext(context.Background())
}
func (i *Component) ToComponentOutputWithContext(ctx context.Context) ComponentOutput {
return pulumi.ToOutputWithContext(ctx, i).(ComponentOutput)
}
type ComponentOutput struct{ *pulumi.OutputState }
func (ComponentOutput) ElementType() reflect.Type {
return reflect.TypeOf((**Component)(nil)).Elem()
}
func (o ComponentOutput) ToComponentOutput() ComponentOutput {
return o
}
func (o ComponentOutput) ToComponentOutputWithContext(ctx context.Context) ComponentOutput {
return o
}
func (o ComponentOutput) A() pulumi.BoolOutput {
return o.ApplyT(func(v *Component) pulumi.BoolOutput { return v.A }).(pulumi.BoolOutput)
}
func (o ComponentOutput) B() pulumi.BoolPtrOutput {
return o.ApplyT(func(v *Component) pulumi.BoolPtrOutput { return v.B }).(pulumi.BoolPtrOutput)
}
func (o ComponentOutput) Bar() FooPtrOutput {
return o.ApplyT(func(v *Component) FooPtrOutput { return v.Bar }).(FooPtrOutput)
}
func (o ComponentOutput) Baz() FooArrayOutput {
return o.ApplyT(func(v *Component) FooArrayOutput { return v.Baz }).(FooArrayOutput)
}
func (o ComponentOutput) C() pulumi.IntOutput {
return o.ApplyT(func(v *Component) pulumi.IntOutput { return v.C }).(pulumi.IntOutput)
}
func (o ComponentOutput) D() pulumi.IntPtrOutput {
return o.ApplyT(func(v *Component) pulumi.IntPtrOutput { return v.D }).(pulumi.IntPtrOutput)
}
func (o ComponentOutput) E() pulumi.StringOutput {
return o.ApplyT(func(v *Component) pulumi.StringOutput { return v.E }).(pulumi.StringOutput)
}
func (o ComponentOutput) F() pulumi.StringPtrOutput {
return o.ApplyT(func(v *Component) pulumi.StringPtrOutput { return v.F }).(pulumi.StringPtrOutput)
}
func (o ComponentOutput) Foo() FooPtrOutput {
return o.ApplyT(func(v *Component) FooPtrOutput { return v.Foo }).(FooPtrOutput)
}
func init() {
pulumi.RegisterInputType(reflect.TypeOf((*ComponentInput)(nil)).Elem(), &Component{})
pulumi.RegisterOutputType(ComponentOutput{})
}
```
|
Israel or Yisrael Mendel Kaplan (April 14, 1913 – April 4, 1985), known as "Reb Mendel" was an American Orthodox Jewish rabbi and author. He was best known as a teacher in the Hebrew Theological College of Chicago and the Talmudical Yeshiva of Philadelphia, where he mentored many future leaders of Orthodox Jewry.
Early life
Yisrael Mendel Kaplan was born in Baranovich, Poland (now Baranavichy, Belarus) to Avraham and Esther Kaplan. Avraham was a lawyer and Esther was involved in community service, raising funds for the yeshiva and feeding the poor.
After his bar mitzvah, Kaplan was enrolled in Yeshiva Ohel Torah-Baranovich, and studied under Elchonon Wasserman. He was considered a very promising student and was assigned Wasserman's son, Naftali, as a study partner. When Wasserman needed to travel overseas in order to raise money for the yeshiva, Kaplan would deliver the lecture in his stead. He later studied in the Mir yeshiva under Yeruchom Levovitz.
In late 1939, during the invasion of Poland, the Jews of Baranovich fled for their lives. Wasserman advised his yeshiva students to regroup in then-independent Vilna, Lithuania. Kaplan, who by this time had gotten married, moved there with his family, where he studied under Yitzchak Zev Soloveitchik. In June 1940, when the Soviet Union occupied Vilna, Jewish life became unbearable. Like the members of the Mir yeshiva and other refugees there, Kaplan sought visas to allow him to escape Nazi and Soviet rule. He obtained a de facto destination visa from the Dutch consul but was unable to obtain the necessary transit visa from the Japanese Vice-consul, Chiune Sugihara, that would allow his family to detour through Japan while awaiting some final, true destination.
The family nevertheless boarded the trains to the Russian port city of Vladivostok. His son, Chaim Ozer, was born on the train ride. After entering Japanese territory by boat, Kaplan expected deportation back to Russia and eventually Siberia. Japanese officials goaded him to produce any kind of visa, and he reluctantly showed them an obviously tampered Japanese transit visa. Inexplicably, it was stamped and accepted and the family continued on to Kobe and then later to Shanghai.
His son Shimon was born in Shanghai, while his middle son, Chaim Ozer got sick and died there.
Career
In 1946, the Kaplans arrived in San Francisco, and from there they went on to Chicago, where Kaplan's brother Hertzl was teaching at the Chicago yeshiva that was to become the Hebrew Theological College. Kaplan accepted a teaching position there, though his students were English-speaking and his English was not yet mastered. Even so, eventually he found success teaching the American youth. He won the students over by offering to "teach them to read the Chicago Tribune if they taught him to read English." His insights into world affairs and reading between the lines of the daily paper (even while needing help with the language) earned him his student's respect.
When his girls were old enough for high school, his wife moved with them to Brooklyn, New York, so they could attend a Jewish girls high school in Williamsburg. Kaplan started Kaplan's Winery Corporation, producing traditional Kosher Concord wine, in an effort to supplement his income to cover his daughter's tuition costs.
By 1965, Kaplan had joined his family in New York and was invited to start teaching the first-level post-high school class in the Talmudical Yeshiva of Philadelphia. He accepted the position, lived in the dormitory, and commuted each weekend to his wife and family in Brooklyn. Kaplan did not consider it beneath his dignity to fix his own car or pick up random hitchhikers from the side of the road. He remained at the Talmudical Yeshiva of Philadelphia and taught the same level until his death on April 4, 1985. To this, Yaakov Kamenetsky commented "Ahzah Kuntz ( What a feat!). He is greater than famous roshei yeshiva, and he can still work quietly under younger men."
Personal life
While studying in Mir in 1933 (or 1935), Kaplan married Sarah Baila Gutman (b. Navahrudak, 1910 – d. New York City, March 12, 2008), the daughter of Tzvi Hirsch Gutman, the administrator of the yeshiva in Baranovich. When Gutman was looking for a match, he asked Elchonon Wasserman about a number of prospects, and Wasserman recommended Kaplan. When Gutman demurred, saying "Isn't your own son, Naftoli, a little better?" Wasserman retorted, "My Naftoli is a good boy, but he doesn't measure up to Mendel". Sarah Baila died in 2008.
The couple had six children: Tzirel, wife of Haim Benoliel, died in 2016; Rachel, wife of David Lopian; Yeruchom Kaplan died in 2022; Chaim Ozer Kaplan, born circa 1942, died in Shanghai; Shimon; and Esther, wife of Shaul Hutner.
Notable students
Moshe Gottesman, dean of the Hebrew Academy of Nassau County
Chaim Malinowitz, dayan (rabbinic judge), general editor of the 73-volume Schottenstein Edition of the Babylonian Talmud
Berel Wein, rabbi, lecturer and author
Yosef Mermelstein, Rosh Yeshiva of Yeshivas Novominsk
Works
Nesivei Yam ("Paths of the Sea") – containing novellae on the Talmudical tractate Kiddushin (2005).
References
Sources
Further reading
External links
A former student's reminiscences of Rabbi Mendel Kaplan
Online Stories of Rabbi Kaplan
1913 births
1985 deaths
People from Baranavichy
People from Novogrudsky Uyezd
Belarusian Jews
American Haredi rabbis
Jewish refugees from Nazi Germany in the Soviet Union
Rosh yeshivas
Hebrew Theological College rosh yeshivas
Jewish Chinese history
Burials at the Jewish cemetery on the Mount of Olives
Mir Yeshiva alumni
|
Paul Caffyn is a sea kayaker based in Runanga on the West Coast of New Zealand. He has completed a number of supported, unsupported, solo and group expeditions by sea kayak in various locations around the world. He has been described as follows by John Dowd:
Caffyn was appointed an Officer of the New Zealand Order of Merit in the 2012 New Year Honours, for services to sea kayaking and water safety.
Expeditions
1978 Circumnavigation of the South Island, New Zealand
The expedition around the South Island started as an expedition along the Fiordland coast with fellow paddler Max Reynolds. Caffyn continued solo and with ground support to complete the circumnavigation in 76 days.{ source: Obscured by waves}
1978/79 Circumnavigation of the North Island, New Zealand
Caffyn sea kayaked solo around the North Island, with ground party support. The circumnavigation took 86 days, after which Caffyn undertook a crossing of Cook Strait by sea kayak.{source: Cresting the Restless Wave}
1979 Circumnavigation of Stewart Island, New Zealand
The expedition around Stewart Island was done with Max Reynolds, August and September 1979. This expedition departed from Bluff, New Zealand starting with a crossing of Foveaux Strait. { source: Dark Side of the Wave}
1980 Circumnavigation of Great Britain
Caffyn and Nigel Dennis circumnavigated Great Britain by sea kayak in 85 days.
1981/82 Circumnavigation of Australia
1985 solo circumnavigation of the four main islands of Japan
1991 completed the first solo sea kayak trip along the entire coastline of Alaska
1997 Circumnavigation of New Caledonia
Two attempts to cross the Tasman Sea by sea kayak
2001/2002 Circumnavigation of Phuket
Bibliography
Caffyn has written a number of books about his expeditions:
The Dreamtime Voyage around Australia Kayak Odyssey
Cresting the Restless Wave, North Island Kayak Odyssey
Dark Side of the Wave, Stewart Island Kayak Odyssey.
Obscured by Waves, South Island Canoe Odyssey.
The Dreamtime Voyage around Australia Kayak Odyssey (25th anniversary edition)
The Search for the Deepest Hole in the World (January 2021) by Paul Caffyn and Van Watson , Kayak Dundee Press
References
External links
Paul Caffyn's website
Coastbusters New Zealand, Paul Caffyns short biography
Article Paddler Magazine
Article regarding Paul Caffyn
Paul Caffyn's The Dreamtime Voyage 25th Anniversary Edition
Living people
Kayakers
Officers of the New Zealand Order of Merit
Year of birth missing (living people)
|
```smalltalk
#if (NETFX_CORE || WINDOWS_UWP)
using Windows.UI.Xaml.Markup;
#else
using System;
using System.Windows.Markup;
#endif
namespace MahApps.Metro.IconPacks
{
#if (NETFX_CORE || WINDOWS_UWP)
[MarkupExtensionReturnType(ReturnType = typeof(PackIconMaterialDesign))]
#else
[MarkupExtensionReturnType(typeof(PackIconMaterialDesign))]
#endif
public class MaterialDesignExtension : BasePackIconExtension
{
public MaterialDesignExtension()
{
}
#if !(NETFX_CORE || WINDOWS_UWP)
public MaterialDesignExtension(PackIconMaterialDesignKind kind)
{
this.Kind = kind;
}
[ConstructorArgument("kind")]
#endif
public PackIconMaterialDesignKind Kind { get; set; }
#if (NETFX_CORE || WINDOWS_UWP)
protected override object ProvideValue()
#else
public override object ProvideValue(IServiceProvider serviceProvider)
#endif
{
return this.GetPackIcon<PackIconMaterialDesign, PackIconMaterialDesignKind>(this.Kind);
}
}
}
```
|
```smalltalk
using System.Linq;
using System.Threading.Tasks;
namespace Volo.Abp.SimpleStateChecking;
public abstract class SimpleBatchStateCheckerBase<TState> : ISimpleBatchStateChecker<TState>
where TState : IHasSimpleStateCheckers<TState>
{
public async Task<bool> IsEnabledAsync(SimpleStateCheckerContext<TState> context)
{
return (await IsEnabledAsync(new SimpleBatchStateCheckerContext<TState>(context.ServiceProvider, new[] { context.State }))).Values.All(x => x);
}
public abstract Task<SimpleStateCheckerResult<TState>> IsEnabledAsync(SimpleBatchStateCheckerContext<TState> context);
}
```
|
```c++
#include <IO/Archives/ZipArchiveReader.h>
#if USE_MINIZIP
#include <IO/Archives/ZipArchiveWriter.h>
#include <IO/ReadBufferFromFileBase.h>
#include <Common/quoteString.h>
#include <base/errnoToString.h>
#include <unzip.h>
namespace DB
{
namespace ErrorCodes
{
extern const int CANNOT_UNPACK_ARCHIVE;
extern const int LOGICAL_ERROR;
extern const int SEEK_POSITION_OUT_OF_BOUND;
extern const int CANNOT_SEEK_THROUGH_FILE;
}
using RawHandle = unzFile;
namespace
{
void checkCompressionMethodIsEnabled(int compression_method_)
{
ZipArchiveWriter::checkCompressionMethodIsEnabled(compression_method_);
}
void checkEncryptionIsEnabled()
{
ZipArchiveWriter::checkEncryptionIsEnabled();
}
}
/// Holds a raw handle, calls acquireRawHandle() in the constructor and releaseRawHandle() in the destructor.
class ZipArchiveReader::HandleHolder
{
public:
HandleHolder() = default;
explicit HandleHolder(const std::shared_ptr<ZipArchiveReader> & reader_) : reader(reader_), raw_handle(reader->acquireRawHandle()) { }
~HandleHolder()
{
if (raw_handle)
{
try
{
closeFile();
}
catch (...)
{
tryLogCurrentException("ZipArchiveReader");
}
reader->releaseRawHandle(raw_handle);
}
}
HandleHolder(HandleHolder && src) noexcept
{
*this = std::move(src);
}
HandleHolder & operator=(HandleHolder && src) noexcept
{
reader = std::exchange(src.reader, nullptr);
raw_handle = std::exchange(src.raw_handle, nullptr);
file_name = std::exchange(src.file_name, {});
file_info = std::exchange(src.file_info, {});
return *this;
}
RawHandle getRawHandle() const { return raw_handle; }
std::shared_ptr<ZipArchiveReader> getReader() const { return reader; }
bool locateFile(const String & file_name_)
{
resetFileInfo();
bool case_sensitive = true;
int err = unzLocateFile(raw_handle, file_name_.c_str(), reinterpret_cast<unzFileNameComparer>(static_cast<size_t>(case_sensitive)));
if (err == UNZ_END_OF_LIST_OF_FILE)
return false;
file_name = file_name_;
return true;
}
bool locateFile(NameFilter filter)
{
int err = unzGoToFirstFile(raw_handle);
if (err == UNZ_END_OF_LIST_OF_FILE)
return false;
do
{
checkResult(err);
resetFileInfo();
retrieveFileInfo();
if (filter(getFileName()))
return true;
err = unzGoToNextFile(raw_handle);
} while (err != UNZ_END_OF_LIST_OF_FILE);
return false;
}
bool tryLocateFile(const String & file_name_)
{
resetFileInfo();
bool case_sensitive = true;
int err = unzLocateFile(raw_handle, file_name_.c_str(), reinterpret_cast<unzFileNameComparer>(static_cast<size_t>(case_sensitive)));
if (err == UNZ_END_OF_LIST_OF_FILE)
return false;
checkResult(err);
file_name = file_name_;
return true;
}
bool firstFile()
{
resetFileInfo();
int err = unzGoToFirstFile(raw_handle);
if (err == UNZ_END_OF_LIST_OF_FILE)
return false;
checkResult(err);
return true;
}
bool nextFile()
{
resetFileInfo();
int err = unzGoToNextFile(raw_handle);
if (err == UNZ_END_OF_LIST_OF_FILE)
return false;
checkResult(err);
return true;
}
const String & getFileName() const
{
if (!file_name)
retrieveFileInfo();
return *file_name;
}
const FileInfoImpl & getFileInfo() const
{
if (!file_info)
retrieveFileInfo();
return *file_info;
}
std::vector<std::string> getAllFiles(NameFilter filter)
{
std::vector<std::string> files;
resetFileInfo();
int err = unzGoToFirstFile(raw_handle);
if (err == UNZ_END_OF_LIST_OF_FILE)
return files;
do
{
checkResult(err);
resetFileInfo();
retrieveFileInfo();
if (!filter || filter(getFileName()))
files.push_back(*file_name);
err = unzGoToNextFile(raw_handle);
} while (err != UNZ_END_OF_LIST_OF_FILE);
return files;
}
void closeFile()
{
int err = unzCloseCurrentFile(raw_handle);
/// If err == UNZ_PARAMERROR the file is already closed.
if (err != UNZ_PARAMERROR)
checkResult(err);
}
void checkResult(int code) const { reader->checkResult(code); }
[[noreturn]] void showError(const String & message) const { reader->showError(message); }
private:
void retrieveFileInfo() const
{
if (file_name && file_info)
return;
unz_file_info64 finfo;
int err = unzGetCurrentFileInfo64(raw_handle, &finfo, nullptr, 0, nullptr, 0, nullptr, 0);
if (err == UNZ_PARAMERROR)
showError("No current file");
checkResult(err);
if (!file_info)
{
file_info.emplace();
file_info->uncompressed_size = finfo.uncompressed_size;
file_info->compressed_size = finfo.compressed_size;
file_info->compression_method = finfo.compression_method;
file_info->is_encrypted = (finfo.flag & MZ_ZIP_FLAG_ENCRYPTED);
}
if (!file_name)
{
file_name.emplace();
file_name->resize(finfo.size_filename);
checkResult(unzGetCurrentFileInfo64(raw_handle, nullptr, file_name->data(), finfo.size_filename, nullptr, 0, nullptr, 0));
}
}
void resetFileInfo()
{
file_info.reset();
file_name.reset();
}
std::shared_ptr<ZipArchiveReader> reader;
RawHandle raw_handle = nullptr;
mutable std::optional<String> file_name;
mutable std::optional<FileInfoImpl> file_info;
};
/// This class represents a ReadBuffer actually returned by readFile().
class ZipArchiveReader::ReadBufferFromZipArchive : public ReadBufferFromFileBase
{
public:
explicit ReadBufferFromZipArchive(HandleHolder && handle_)
: ReadBufferFromFileBase(DBMS_DEFAULT_BUFFER_SIZE, nullptr, 0)
, handle(std::move(handle_))
{
const auto & file_info = handle.getFileInfo();
checkCompressionMethodIsEnabled(file_info.compression_method);
const char * password_cstr = nullptr;
if (file_info.is_encrypted)
{
const auto & password_str = handle.getReader()->password;
if (password_str.empty())
showError("Password is required");
password_cstr = password_str.c_str();
checkEncryptionIsEnabled();
}
RawHandle raw_handle = handle.getRawHandle();
int err = unzOpenCurrentFilePassword(raw_handle, password_cstr);
if (err == MZ_PASSWORD_ERROR)
showError("Wrong password");
checkResult(err);
}
off_t seek(off_t off, int whence) override
{
off_t current_pos = getPosition();
off_t new_pos;
if (whence == SEEK_SET)
new_pos = off;
else if (whence == SEEK_CUR)
new_pos = off + current_pos;
else
throw Exception(ErrorCodes::SEEK_POSITION_OUT_OF_BOUND, "Only SEEK_SET and SEEK_CUR seek modes allowed.");
if (new_pos == current_pos)
return current_pos; /// The position is the same.
if (new_pos < 0)
throw Exception(ErrorCodes::SEEK_POSITION_OUT_OF_BOUND, "Seek position is out of bound");
off_t working_buffer_start_pos = current_pos - offset();
off_t working_buffer_end_pos = current_pos + available();
if ((working_buffer_start_pos <= new_pos) && (new_pos <= working_buffer_end_pos))
{
/// The new position is still inside the buffer.
position() += new_pos - current_pos;
return new_pos;
}
RawHandle raw_handle = handle.getRawHandle();
/// Check that the new position is now beyond the end of the file.
const auto & file_info = handle.getFileInfo();
if (new_pos > static_cast<off_t>(file_info.uncompressed_size))
throw Exception(ErrorCodes::SEEK_POSITION_OUT_OF_BOUND, "Seek position is out of bound");
/// unzSeek64() works only for non-compressed files.
///
/// We used to have a fallback here, where we would:
/// * ignore() to "seek" forward,
/// * unzCloseCurrentFile(raw_handle) + unzOpenCurrentFile(raw_handle) to seek to the
/// beginning of the file.
/// But the close+open didn't work: after closing+reopening once, the second
/// unzCloseCurrentFile() was failing with MZ_CRC_ERROR in mz_zip_entry_read_close(). Maybe
/// it's a bug in minizip where some state was inadvertently left over after close+reopen.
/// Didn't investigate because re-reading the whole file should be avoided anyway.
if (file_info.compression_method != MZ_COMPRESS_METHOD_STORE)
throw Exception(ErrorCodes::CANNOT_SEEK_THROUGH_FILE, "Seek in compressed archive is not supported.");
checkResult(unzSeek64(raw_handle, off, whence));
return unzTell64(raw_handle);
}
bool checkIfActuallySeekable() override
{
/// The library doesn't support seeking in compressed files.
return handle.getFileInfo().compression_method == MZ_COMPRESS_METHOD_STORE;
}
off_t getPosition() override
{
RawHandle raw_handle = handle.getRawHandle();
return unzTell64(raw_handle) - available();
}
String getFileName() const override { return handle.getFileName(); }
std::optional<size_t> tryGetFileSize() override { return handle.getFileInfo().uncompressed_size; }
/// Releases owned handle to pass it to an enumerator.
HandleHolder releaseHandle() &&
{
handle.closeFile();
return std::move(handle);
}
private:
bool nextImpl() override
{
RawHandle raw_handle = handle.getRawHandle();
auto bytes_read = unzReadCurrentFile(raw_handle, internal_buffer.begin(), static_cast<int>(internal_buffer.size()));
if (bytes_read < 0)
checkResult(bytes_read);
if (!bytes_read)
return false;
working_buffer = internal_buffer;
working_buffer.resize(bytes_read);
return true;
}
void checkResult(int code) const { handle.checkResult(code); }
[[noreturn]] void showError(const String & message) const { handle.showError(message); }
HandleHolder handle;
};
class ZipArchiveReader::FileEnumeratorImpl : public FileEnumerator
{
public:
explicit FileEnumeratorImpl(HandleHolder && handle_) : handle(std::move(handle_)) {}
const String & getFileName() const override { return handle.getFileName(); }
const FileInfo & getFileInfo() const override { return handle.getFileInfo(); }
bool nextFile() override { return handle.nextFile(); }
/// Releases owned handle to pass it to a read buffer.
HandleHolder releaseHandle() && { return std::move(handle); }
private:
HandleHolder handle;
};
namespace
{
/// Provides a set of functions allowing the minizip library to read its input
/// from a SeekableReadBuffer instead of an ordinary file in the local filesystem.
class StreamFromReadBuffer
{
public:
static RawHandle open(std::unique_ptr<SeekableReadBuffer> archive_read_buffer, UInt64 archive_size)
{
StreamFromReadBuffer::Opaque opaque{std::move(archive_read_buffer), archive_size};
zlib_filefunc64_def func_def;
func_def.zopen64_file = &StreamFromReadBuffer::openFileFunc;
func_def.zclose_file = &StreamFromReadBuffer::closeFileFunc;
func_def.zread_file = &StreamFromReadBuffer::readFileFunc;
func_def.zwrite_file = &StreamFromReadBuffer::writeFileFunc;
func_def.zseek64_file = &StreamFromReadBuffer::seekFunc;
func_def.ztell64_file = &StreamFromReadBuffer::tellFunc;
func_def.zerror_file = &StreamFromReadBuffer::testErrorFunc;
func_def.opaque = &opaque;
return unzOpen2_64(/* path= */ nullptr,
&func_def);
}
private:
std::unique_ptr<SeekableReadBuffer> read_buffer;
UInt64 start_offset = 0;
UInt64 total_size = 0;
bool at_end = false;
struct Opaque
{
std::unique_ptr<SeekableReadBuffer> read_buffer;
UInt64 total_size = 0;
};
static void * openFileFunc(void * opaque, const void *, int)
{
auto & opq = *reinterpret_cast<Opaque *>(opaque);
return new StreamFromReadBuffer(std::move(opq.read_buffer), opq.total_size);
}
StreamFromReadBuffer(std::unique_ptr<SeekableReadBuffer> read_buffer_, UInt64 total_size_)
: read_buffer(std::move(read_buffer_)), start_offset(read_buffer->getPosition()), total_size(total_size_) {}
static int closeFileFunc(void *, void * stream)
{
delete reinterpret_cast<StreamFromReadBuffer *>(stream);
return ZIP_OK;
}
static StreamFromReadBuffer & get(void * ptr)
{
return *reinterpret_cast<StreamFromReadBuffer *>(ptr);
}
static int testErrorFunc(void *, void *)
{
return ZIP_OK;
}
static unsigned long readFileFunc(void *, void * stream, void * buf, unsigned long size) // NOLINT(google-runtime-int)
{
auto & strm = get(stream);
if (strm.at_end)
return 0;
auto read_bytes = strm.read_buffer->read(reinterpret_cast<char *>(buf), size);
return read_bytes;
}
static ZPOS64_T tellFunc(void *, void * stream)
{
auto & strm = get(stream);
if (strm.at_end)
return strm.total_size;
auto pos = strm.read_buffer->getPosition() - strm.start_offset;
return pos;
}
static long seekFunc(void *, void * stream, ZPOS64_T offset, int origin) // NOLINT(google-runtime-int)
{
auto & strm = get(stream);
if (origin == SEEK_END)
{
/// Our implementations of SeekableReadBuffer don't support SEEK_END,
/// but the minizip library needs it, so we have to simulate it here.
strm.at_end = true;
return ZIP_OK;
}
strm.at_end = false;
if (origin == SEEK_SET)
offset += strm.start_offset;
strm.read_buffer->seek(offset, origin);
return ZIP_OK;
}
static unsigned long writeFileFunc(void *, void *, const void *, unsigned long) // NOLINT(google-runtime-int)
{
throw Exception(ErrorCodes::LOGICAL_ERROR, "StreamFromReadBuffer::writeFile must not be called");
}
};
}
ZipArchiveReader::ZipArchiveReader(const String & path_to_archive_)
: path_to_archive(path_to_archive_)
{
init();
}
ZipArchiveReader::ZipArchiveReader(
const String & path_to_archive_, const ReadArchiveFunction & archive_read_function_, UInt64 archive_size_)
: path_to_archive(path_to_archive_), archive_read_function(archive_read_function_), archive_size(archive_size_)
{
init();
}
void ZipArchiveReader::init()
{
/// Prepare the first handle in `free_handles` and check that the archive can be read.
releaseRawHandle(acquireRawHandle());
}
ZipArchiveReader::~ZipArchiveReader()
{
/// Close all `free_handles`.
for (RawHandle free_handle : free_handles)
{
try
{
checkResult(unzClose(free_handle));
}
catch (...)
{
tryLogCurrentException("ZipArchiveReader");
}
}
}
const std::string & ZipArchiveReader::getPath() const
{
return path_to_archive;
}
bool ZipArchiveReader::fileExists(const String & filename)
{
return acquireHandle().tryLocateFile(filename);
}
ZipArchiveReader::FileInfo ZipArchiveReader::getFileInfo(const String & filename)
{
auto handle = acquireHandle();
if (!handle.locateFile(filename))
showError(fmt::format("File {} was not found in archive", quoteString(filename)));
return handle.getFileInfo();
}
std::unique_ptr<ZipArchiveReader::FileEnumerator> ZipArchiveReader::firstFile()
{
auto handle = acquireHandle();
if (!handle.firstFile())
return nullptr;
return std::make_unique<FileEnumeratorImpl>(std::move(handle));
}
std::unique_ptr<ReadBufferFromFileBase> ZipArchiveReader::readFile(const String & filename, bool throw_on_not_found)
{
auto handle = acquireHandle();
if (!handle.locateFile(filename))
{
if (throw_on_not_found)
showError(fmt::format("File {} was not found in archive", quoteString(filename)));
return nullptr;
}
return std::make_unique<ReadBufferFromZipArchive>(std::move(handle));
}
std::unique_ptr<ReadBufferFromFileBase> ZipArchiveReader::readFile(NameFilter filter, bool throw_on_not_found)
{
auto handle = acquireHandle();
if (!handle.locateFile(filter))
{
if (throw_on_not_found)
showError(fmt::format("No file satisfying filter in archive"));
return nullptr;
}
return std::make_unique<ReadBufferFromZipArchive>(std::move(handle));
}
std::unique_ptr<ReadBufferFromFileBase> ZipArchiveReader::readFile(std::unique_ptr<FileEnumerator> enumerator)
{
if (!dynamic_cast<FileEnumeratorImpl *>(enumerator.get()))
throw Exception(ErrorCodes::LOGICAL_ERROR, "Wrong enumerator passed to readFile()");
auto enumerator_impl = std::unique_ptr<FileEnumeratorImpl>(static_cast<FileEnumeratorImpl *>(enumerator.release()));
auto handle = std::move(*enumerator_impl).releaseHandle();
return std::make_unique<ReadBufferFromZipArchive>(std::move(handle));
}
std::unique_ptr<ZipArchiveReader::FileEnumerator> ZipArchiveReader::nextFile(std::unique_ptr<ReadBuffer> read_buffer)
{
if (!dynamic_cast<ReadBufferFromZipArchive *>(read_buffer.get()))
throw Exception(ErrorCodes::LOGICAL_ERROR, "Wrong ReadBuffer passed to nextFile()");
auto read_buffer_from_zip = std::unique_ptr<ReadBufferFromZipArchive>(static_cast<ReadBufferFromZipArchive *>(read_buffer.release()));
auto handle = std::move(*read_buffer_from_zip).releaseHandle();
if (!handle.nextFile())
return nullptr;
return std::make_unique<FileEnumeratorImpl>(std::move(handle));
}
std::unique_ptr<ZipArchiveReader::FileEnumerator> ZipArchiveReader::currentFile(std::unique_ptr<ReadBuffer> read_buffer)
{
if (!dynamic_cast<ReadBufferFromZipArchive *>(read_buffer.get()))
throw Exception(ErrorCodes::LOGICAL_ERROR, "Wrong ReadBuffer passed to nextFile()");
auto read_buffer_from_zip = std::unique_ptr<ReadBufferFromZipArchive>(static_cast<ReadBufferFromZipArchive *>(read_buffer.release()));
auto handle = std::move(*read_buffer_from_zip).releaseHandle();
return std::make_unique<FileEnumeratorImpl>(std::move(handle));
}
std::vector<std::string> ZipArchiveReader::getAllFiles()
{
return getAllFiles({});
}
std::vector<std::string> ZipArchiveReader::getAllFiles(NameFilter filter)
{
auto handle = acquireHandle();
return handle.getAllFiles(filter);
}
void ZipArchiveReader::setPassword(const String & password_)
{
std::lock_guard lock{mutex};
password = password_;
}
ZipArchiveReader::HandleHolder ZipArchiveReader::acquireHandle()
{
return HandleHolder{std::static_pointer_cast<ZipArchiveReader>(shared_from_this())};
}
ZipArchiveReader::RawHandle ZipArchiveReader::acquireRawHandle()
{
std::lock_guard lock{mutex};
if (!free_handles.empty())
{
RawHandle free_handle = free_handles.back();
free_handles.pop_back();
return free_handle;
}
RawHandle new_handle = nullptr;
if (archive_read_function)
new_handle = StreamFromReadBuffer::open(archive_read_function(), archive_size);
else
new_handle = unzOpen64(path_to_archive.c_str());
if (!new_handle)
throw Exception(ErrorCodes::CANNOT_UNPACK_ARCHIVE, "Couldn't open zip archive {}", quoteString(path_to_archive));
return new_handle;
}
void ZipArchiveReader::releaseRawHandle(RawHandle handle_)
{
if (!handle_)
return;
std::lock_guard lock{mutex};
free_handles.push_back(handle_);
}
void ZipArchiveReader::checkResult(int code) const
{
if (code >= UNZ_OK)
return;
String message = "Code = ";
switch (code)
{
case UNZ_OK: return;
case UNZ_ERRNO: message += "ERRNO, errno = " + errnoToString(); break;
case UNZ_PARAMERROR: message += "PARAMERROR"; break;
case UNZ_BADZIPFILE: message += "BADZIPFILE"; break;
case UNZ_INTERNALERROR: message += "INTERNALERROR"; break;
case UNZ_CRCERROR: message += "CRCERROR"; break;
case UNZ_BADPASSWORD: message += "BADPASSWORD"; break;
default: message += std::to_string(code); break;
}
showError(message);
}
void ZipArchiveReader::showError(const String & message) const
{
throw Exception(ErrorCodes::CANNOT_UNPACK_ARCHIVE, "Couldn't unpack zip archive {}: {}", quoteString(path_to_archive), message);
}
}
#endif
```
|
```javascript
import { useState } from 'react'
import { createContext } from 'react'
import { useEffect, useImperativeHandle } from 'react'
import {
Component,
createFactory,
PureComponent,
useDeferredValue,
useInsertionEffect,
useLayoutEffect,
useReducer,
useRef,
useSyncExternalStore,
} from 'react'
import { experimental_useOptimistic as useOptimistic } from 'react'
export default function () {
return null
}
```
|
Charles Wreford-Brown (9 October 1866 – 26 November 1951) was an English sportsman. He captained the England national football team and was a county cricketer during the Victorian age, and later acted as a sports legislator during the 20th century. Wreford-Brown is usually credited with inventing the term soccer as an abbreviation for association football.
Upbringing and amateur status
Wreford-Brown was born in Bristol went to Charterhouse School before studying at Oriel College, Oxford. Given his privileged economic status at the time of the rise in the popularity of football, Wreford-Brown was one of a select few who were able to play sports for no monetary gain whatsoever.
The educated belief in the purity of a noble athletic spirit untainted by the corrupting influence of money was embodied within the rise of the Corinthian football club who Wreford-Brown played for in the 1890s. Indeed, in 1906 Wreford-Brown was one of the leading figures in the movement to create the Amateur Football Alliance in London in order to keep the amateur game separate from the Football Association, an organisation that the amateur clubs found to be increasingly driven by the financial gain of the professional clubs.
Sporting Achievement
He was a keen sportsman at the University of Oxford and played both cricket and football for the university. He also later played cricket for Gloucestershire. His younger brother, Oswald (who died during the first World War in 1916) and son Anthony would, like him, also play for first-class cricket but none were stand-outs with the willow.
However it is as a footballer that he is more recognised. He first played as a goalkeeper but played initially as a stop-gap but later as the mainstay centre-half for the Old Carthusians (the club for ex-Charterhouse boys) (appearing against them in the 1896 London Charity Cup final, Clifton Association (the Association which took in Bristol and its environs and with whom he played in the inaugural Gloucestershire Cup), as well as the Corinthians and captained England twice against Wales in 1894 and 1895 (when the team consisted entirely of amateur players).
Steve Bloomer, one of the leading "players" (professionals) on the England team, recorded in a memoir that, as captain, the patrician Wreford-Brown on one occasion took to the field with a deep pocket in his shorts filled with gold sovereigns and pressed one of the coins into the hand of each professional goalscorer after the man had netted.
Corinthian FC
Charles Wreford-Brown was a leading figure for the era's most prominent football club, Corinthian FC. A constant figure throughout the club's golden era, he played 161 games for the club, scoring 8 goals. In 1894, Corinthian FC became the only club still to this day, to ever fully represent the England National side, and Charles Wreford-Brown would Captain the side. He would too, when the extraordinary feat was repeated a year later.
Corinthian FC were strict amateurs who believed in fair play and who had the "Corinthian Spirit" named in their honour. They are the team credited with having popularised the sport around the world with many tours and with them, Wreford-Brown travelled to S.Africa, USA, Canada, Sweden & Denmark.
A strong defender, Wreford-Brown played in some of the club's famous victories over professional opponents such as Liverpool, Southampton, Sunderland and Spurs.
Legislator
He was first appointed to the council of The Football Association to represent the Old Carthusians in 1892 but soon after served as the representative for Oxford University, a position he held until his death some 59 years later. He later became Chairman of the International Selection Committee for England within the Football Association.
He was in attendance at the first meeting of the Athenian League on 27 May 1914. He served as a vice-president of the FA from 1941 until his death in 1951, under Sir Stanley Rous, secretary of the Association. They have been credited with guiding the Association toward a more educated position, promoting youth coaching and training just before hostilities in 1939.
He was also a keen chess player. In 1924, in Paris Charles Wreford-Brown participated in unofficial Chess Olympiad. He took part in the 1933 British Chess Championship, though he had to drop out through illness after two rounds (he had won the first game and drawn the second).
References
External links
Bibliography
Further reading
1866 births
1951 deaths
Cricketers from Bristol
England men's international footballers
English men's footballers
Clifton Association F.C. players
Oxford University A.F.C. players
Corinthian F.C. players
English cricketers
Gloucestershire cricketers
Oxford University cricketers
People educated at Charterhouse School
Alumni of Oriel College, Oxford
Footballers from Bristol
Old Carthusians F.C. players
Men's association football defenders
Charles
Lord Hawke's XI cricketers
English chess players
|
The Civilian Board of Contract Appeals (CBCA) is an Article I court that was established under the Contract Disputes Act of 1978 as an independent tribunal to hear and decide contract disputes between Government contractors and the General Services Administration (GSA) and other civilian Executive agencies of the United States.
Jurisdiction
The Civilian Board of Contract Appeals decides disputes between Government contractors and Executive agencies of the United States. The Board's authority extends to all Executive agencies other than the Department of Defense, the National Aeronautics and Space Administration, the United States Postal Service, the Postal Regulatory Commission, the Federal Aviation Administration ((d)(4)), and the Tennessee Valley Authority.
Its original jurisdiction over claims involving Government contract disputes partially overlaps as concurrent jurisdiction with the United States Court of Federal Claims under the Contract Disputes Act of 1978, and the "Big" Tucker Act (), but not the United States district courts for claims less than $10,000 under the "Little" Tucker Act ((a)(2)). The United States Court of Appeals for the Federal Circuit may exercise appellate jurisdiction over decisions of the Board involving Government contract disputes ( and (a)(1)).
The Board also hears and decides various additional classes of cases, including:
Cases arising under the Indian Self-Determination Act, et seq.;
Disputes between insurance companies and the U.S. Department of Agriculture's Risk Management Agency involving actions of the Federal Crop Insurance Corporation under et seq.;
Claims by Federal employees under for reimbursement of expenses incurred while on official temporary duty travel or in connection with relocation to a new duty station;
Claims by carriers or freight forwarders under (i)(1) involving actions of the General Services Administration regarding payment for transportation services;
Claims under the Federal Emergency Management Agency's Public Assistance Grant Program funding resulting from damages incurred by Hurricanes Katrina and Rita (); and
Claims for the proceeds of the sale of property of certain Federal civilian employees who are dead, ill, or missing under .
Procedure
The Board uses a variety of techniques intended to shorten and simplify, when appropriate, the formal proceedings normally used to resolve contract disputes. The Board fully supports the use of alternative dispute resolution (ADR) in all appropriate cases; it encourages the prompt, expert, and inexpensive resolution of contract disputes as promoted by the Administrative Dispute Resolution Act. In addition, the Board provides to other Executive agencies, when jointly requested by an agency and its contractor, alternative dispute resolution services on contract-related matters, whether arising before or after a contract has been awarded.
History
The Civilian Board of Contract Appeals was established by Section 847 of the National Defense Authorization Act for Fiscal Year 2006, with an effective date of January 6, 2007, to hear and decide contract disputes between Government contractors and Executive agencies under the provisions of the Contract Disputes Act of 1978, and regulations and rules issued under that statute. The Civilian Board of Contract Appeals was created by consolidating eight former boards of contract appeals:
General Services Administration Board of Contract Appeals (GSBCA)
Department of Transportation Board of Contract Appeals (DOTBCA)
Department of Agriculture Board of Contract Appeals (AGBCA)
Department of Veterans Affairs Board of Contract Appeals (VABCA)
Department of the Interior Board of Contract Appeals (IBCA)
Department of Energy Board of Contract Appeals (EBCA)
Department of Housing and Urban Development Board of Contract Appeals (HUDBCA)
Department of Labor Board of Contract Appeals (LBCA)
See also
Contract Disputes Act of 1978
Tucker Act
Armed Services Board of Contract Appeals
United States Court of Federal Claims
United States Court of Appeals for the Federal Circuit
References
External links
Contract
General Services Administration
Government procurement in the United States
2007 establishments in the United States
Courts and tribunals established in 2007
|
```javascript
import Icon from '../components/Icon.vue'
Icon.register({
trash: {
width: 448,
height: 512,
paths: [
{
d: 'M432 32c8.8 0 16 7.2 16 16v32c0 8.8-7.2 16-16 16h-416c-8.8 0-16-7.2-16-16v-32c0-8.8 7.2-16 16-16h120l9.4-18.7c3.9-7.9 11.9-13.3 21.3-13.3h0.1 114.3c0 0 0 0 0 0 9.4 0 17.6 5.4 21.5 13.3l9.4 18.7h120zM53.2 467l-21.2-339h384l-21.2 339c-1.6 25.1-22.4 45-47.9 45h-245.8c-25.5 0-46.3-19.9-47.9-45z'
}
]
}
})
```
|
```objective-c
/*
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
*
* along with this program. If not, see <path_to_url
*
* Author: huaxz1986@163.com (huaxz)
*/
#ifndef DFS
#define DFS
#include<memory>
#include<functional>
namespace IntroductionToAlgorithm
{
namespace GraphAlgorithm
{
//!visit2222.3
/*!
* \param graph:
* \param v_id:`id`
* \param time:`visit`
* \param pre_action:`id``time`
* \param post_action:`id``time`
*
* `v_id`
*
* - `v_id``[0,N)``v_id`
* - `graph``id``v_id``v_id`
*
* visitv_id
*
* - time
* - v_id
* - v_id
* - v_id time v_id
*
*/
template<typename GraphType>
void visit(std::shared_ptr<GraphType> graph,typename GraphType::VIDType v_id,int&time,
std::function<void(typename GraphType::VIDType,int)> pre_action=[](typename GraphType::VIDType,int){},
std::function<void(typename GraphType::VIDType,int)> post_action=[](typename GraphType::VIDType,int){})
{
if(!graph)
throw std::invalid_argument("visit error: graph must not be nullptr!");
if(v_id<0||v_id>=GraphType::NUM||!graph->vertexes.at(v_id))
throw std::invalid_argument("visit error: v_id muse belongs [0,N) and graph->vertexes[v_id] must not be nullptr!");
time++;
//******* *****************
pre_action(v_id,time);
graph->vertexes.at(v_id)->set_disovered(time);
//******** *************
for(const auto&edge:graph->vertex_edge_tuples(v_id))
{
auto another_id=std::get<1>(edge);
auto another_vertex=graph->vertexes.at(another_id);
if(another_vertex->color==GraphType::VertexType::COLOR::WHITE)
{
another_vertex->parent=graph->vertexes.at(v_id);
visit(graph,another_id,time,pre_action,post_action);
}
}
//***********
time++;
graph->vertexes.at(v_id)->set_finished(time);
post_action(v_id,time);
}
//!depth_first_search2222.3
/*!
* \param graph:
* \param pre_root_action:`id``time`
* \param post_root_action:`id``time`
* \param pre_action:`id``time`
* \param post_action:`id``time`
* \param search_order:)`id`
* \return:void
*
* vvvv
*
*
*
* vdiscover_timevvfinish_timevv
* vv.discover_timev.discover_timev.finish_timev.finish_time
*
*
*
* - (DFS_Vertexcolor)
* - time 0
* - Vv
* -v visit
* > visit v
* >
* > V
*
* O(V+E)
*
* :
*
* - G_pai
* - v u vu
* - "(u"u"u)"u
* uv
* - [u.discover_time,u.finish_time][v.discover_time,v.finish_time]
* uvvu
* - [u.discover_time,u.finish_time][v.discover_time,v.finish_time]uv
* - [v.discover_time,v.finish_time][u.discover_time,u.finish_time]vu
*
* GG_pai
*
* - v(u,v)(u,v)
* - (u,v)uv
* - uv
* -
*
* (u,v)
*
* - v(u,v)
* - v(u,v)
* - v(u,v)
* - u.discover_time< v.discover_time
* - u.discover_time< v.discover_time
*
*
*
*/
template<typename GraphType>
void depth_first_search(std::shared_ptr<GraphType> graph,
std::function<void(typename GraphType::VIDType,int)> pre_action=[](typename GraphType::VIDType,int){},
std::function<void(typename GraphType::VIDType,int)> post_action=[](typename GraphType::VIDType,int){},
std::function<void(typename GraphType::VIDType,int)> pre_root_action=[](typename GraphType::VIDType,int){},
std::function<void(typename GraphType::VIDType,int)> post_root_action=[](typename GraphType::VIDType,int){},
const std::vector<typename GraphType::VIDType>& search_order=std::vector<typename GraphType::VIDType>())
{
typedef typename GraphType::VIDType VIDType;
typedef typename GraphType::VertexType VertexType;
if(!graph)
throw std::invalid_argument("depth_first_search error: graph must not be nullptr!");
//************ search_order ****************
std::vector<VIDType> real_search_order;
if(!search_order.size())
{
for(int i=0;i<GraphType::NUM;i++)
real_search_order.push_back(i);
}else
real_search_order=search_order;
//************* ****************
for(auto& v:graph->vertexes)
{
if(!v) continue;
v->color=VertexType::COLOR::WHITE;
v->key=0;
v->parent=std::shared_ptr<VertexType>();
}
//*************** *************
int time=0;
for(const auto& v_id :real_search_order)
{
if(v_id<0||v_id>=GraphType::NUM||!graph->vertexes.at(v_id)) //
continue;
auto v=graph->vertexes.at(v_id);
if(v->color==GraphType::VertexType::COLOR::WHITE)
{
pre_root_action(v_id,time);
visit(graph,v->id,time,pre_action,post_action);
post_root_action(v_id,time);
}
}
}
}
}
#endif // DFS
```
|
Jens's slender skink (Brachymeles vindumi) is a species of skink endemic to the Philippines.
References
Reptiles of the Philippines
Reptiles described in 2010
Brachymeles
|
The Original Church of God or Sanctified Church is an association of holiness Christian churches headquartered in Nashville, Tennessee. The members and clergy of the churches are predominantly African-American. The official name of the body is The Original Church of God or Sanctified Church, General Body.
History
The church's roots are in the holiness movement. In the 1890s a group of African American Baptist ministers, led by Charles Price Jones and Charles Harrison Mason, were dismissed by the Baptist Church for preaching entire sanctification. After a number of unaffiliated revivals, a church was formed in Jackson, Mississippi, by Jones, Mason, and others. Originally called the "Church of God", it was soon renamed the "Church of God in Christ" and had affiliated churches in a number of cities. During this time an elder of the church, Charles W. Gray formed a number of Church of God in Christ churches in and around Nashville.
The Church of God in Christ split in 1907 over the issue of pentecostalism, with both factions continuing to use the name "Church of God in Christ" until 1915 when the pentecostal faction, led by Mason, incorporated under that name, Church of God in Christ. The non-pentecostal faction led by Jones began using the name Church of Christ (Holiness) U.S.A., and incorporated under that name in 1920. At the time of the 1907 schism, Gray's churches also split from the Church of God in Christ. Though they were also non-pentecostal and were doctrinally identical to Jones' faction, they were independent from Jones' body and were congregational in organization. Gray's churches were known by the name "Church of God (Sanctified Church)". In 1927 the Church of God (Sanctified Church) incorporated under the name "Church of God, or Sanctified Church" (subsequently changed to "Church of God Sanctified, Incorporated") and created a board of elders as its governing body. The new board approved the ordination of women, which Gray opposed, and in that same year Gray and a group of members broke away to form a new body, the "Original Church of God or Sanctified Church." Both bodies still exist today.
Gray remained the leader of the church until his death in 1945, followed by William Crosby until 1952, and T.R. Jeffries.
Churches and membership
The body includes about 63 churches. As of the 1970s it had about 5,000 members.
See also
Original Church of God (Pulaski, Tennessee)
References
External links
Official Site
African-American history in Nashville, Tennessee
African-American churches in Tennessee
Holiness denominations
Historically African-American Christian denominations
Christian organizations established in 1927
Christian denominations established in the 20th century
Church of God denominations
Pentecostal denominations in North America
Pentecostalism in the United States
|
```xml
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="path_to_url">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{EE61B7EF-EC45-4165-8B59-FD5B7D2A908C}</ProjectGuid>
<RootNamespace>Fastest_icl_interval</RootNamespace>
<Keyword>Win32Proj</Keyword>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<CharacterSet>Unicode</CharacterSet>
<WholeProgramOptimization>true</WholeProgramOptimization>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup>
<_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">../../../../bin/debug/\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">../../../../bin/obj/$(ProjectName)/debug/\</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../../../../bin/release/\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../../../../bin/obj/$(ProjectName)/release/\</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>../../../../;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<DebugInformationFormat>EditAndContinue</DebugInformationFormat>
</ClCompile>
<Link>
<OutputFile>../../../../bin/debug/$(ProjectName).exe</OutputFile>
<AdditionalLibraryDirectories>../../../../lib; ../../../../stage/lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<GenerateDebugInformation>true</GenerateDebugInformation>
<SubSystem>Console</SubSystem>
<RandomizedBaseAddress>false</RandomizedBaseAddress>
<DataExecutionPrevention>
</DataExecutionPrevention>
<TargetMachine>MachineX86</TargetMachine>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<AdditionalIncludeDirectories>../../../../;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Link>
<OutputFile>../../../../bin/release/$(ProjectName).exe</OutputFile>
<AdditionalLibraryDirectories>../../../../lib; ../../../../stage/lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<GenerateDebugInformation>true</GenerateDebugInformation>
<SubSystem>Console</SubSystem>
<OptimizeReferences>true</OptimizeReferences>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<RandomizedBaseAddress>false</RandomizedBaseAddress>
<DataExecutionPrevention>
</DataExecutionPrevention>
<TargetMachine>MachineX86</TargetMachine>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="fastest_icl_interval.cpp" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>
```
|
Reckart Mill, also known as Albright Mill, is a historic grist mill located near Cranesville, Preston County, West Virginia. It was built in 1865, and is a frame, 2 1/2-story gable roofed building that is built, in part, over Muddy Creek. It is notable for its interior structural beam support system of hand hewn pine timbers and mill machinery. Operations at Reckart Mill ceased in 1943. In 2017 the mill was torn down by the new owners and the surrounding area was clear cut by the owners.
It was listed on the National Register of Historic Places in 1980.
References
Grinding mills on the National Register of Historic Places in West Virginia
Industrial buildings completed in 1865
Buildings and structures in Preston County, West Virginia
Grinding mills in West Virginia
National Register of Historic Places in Preston County, West Virginia
1865 establishments in West Virginia
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.