Grcov report - property.rs

1

use crate::common::{

2

    CalendarDateTime, CalendarUserType, Encoding, FreeBusyTimeType, ParticipationStatusUnknown,

3

    Range, RelationshipType, Role, Status, TimeTransparency, TriggerRelationship, Value,

4

};

5

use crate::model::object::ICalObjectBuilder;

6

use crate::model::param::{

7

    add_is_utc, altrep_param, common_name_param, directory_entry_reference_param, language_param,

8

    sent_by_param, tz_id_param, CalendarUserTypeParam, DelegatedFromParam, DelegatedToParam,

9

    EncodingParam, FormatTypeParam, FreeBusyTimeTypeParam, MembersParam, ParticipationStatusParam,

10

    RangeParam, RelationshipTypeParam, RoleParam, RsvpParam, TriggerRelationshipParam,

11

    ValueTypeParam,

12

};

13

use crate::model::param::{impl_other_component_params_builder, impl_other_params_builder, Param};

14

use std::fmt::Display;

15

use std::marker::PhantomData;

16

17

mod duration;

18

mod recur;

19

20

use crate::error::AetoliaResult;

21

use crate::model::impl_property_access;

22

pub use duration::*;

23

pub use recur::*;

24

25

pub trait AddComponentProperty {

26

    fn add_property(&mut self, property: ComponentProperty);

27

28

29

pub trait DateTimeQuery {

30

    fn is_date(&self) -> bool;

31

    fn is_local_time(&self) -> bool;

32

    fn is_utc(&self) -> bool;

33

    fn is_local_time_with_timezone(&self) -> bool;

34

35

36

macro_rules! impl_date_time_query {

37

    ($for_type:ty) => {

38

        impl DateTimeQuery for $for_type {

39

            fn is_date(&self) -> bool {

40

                self.value.is_date()

41

42

43

            // Form 1, local date-time

44

28

            fn is_local_time(&self) -> bool {

45

28

                self.value.is_date_time()

46

28

                    && !self.value.is_utc()

47

22

                    && !self

48

22

                        .params

49

22

                        .iter()

50

26

                        .any(|p| matches!(p, Param::TimeZoneId { .. }))

51

28

52

53

            // Form 2, UTC date-time

54

26

            fn is_utc(&self) -> bool {

55

26

                self.value.is_date_time() && self.value.is_utc()

56

26

57

58

            // Form 3, date-time in a specific time zone

59

20

            fn is_local_time_with_timezone(&self) -> bool {

60

20

                self.value.is_date_time()

61

20

                    && self

62

20

                        .params

63

20

                        .iter()

64

24

                        .any(|p| matches!(p, Param::TimeZoneId { .. }))

65

20

66

67

};

68

69

70

#[derive(Debug, Eq, PartialEq)]

71

pub enum Classification {

72

    Public,

73

    Private,

74

    Confidential,

75

    XName(String),

76

    IanaToken(String),

77

78

79

impl Display for Classification {

80

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

81

        let str = match self {

82

            Classification::Public => "PUBLIC".to_string(),

83

            Classification::Private => "PRIVATE".to_string(),

84

            Classification::Confidential => "CONFIDENTIAL".to_string(),

85

            Classification::XName(name) => name.to_string(),

86

            Classification::IanaToken(token) => token.to_string(),

87

};

88

        write!(f, "{}", str)

89

90

91

92

pub enum StatusEvent {

93

    Tentative,

94

    Confirmed,

95

    Cancelled,

96

97

98

impl From<StatusEvent> for Status {

99

14

    fn from(status: StatusEvent) -> Self {

100

14

        match status {

101

2

            StatusEvent::Tentative => Status::Tentative,

102

12

            StatusEvent::Confirmed => Status::Confirmed,

103

            StatusEvent::Cancelled => Status::Cancelled,

104

105

14

106

107

108

pub enum StatusToDo {

109

    NeedsAction,

110

    Completed,

111

    InProcess,

112

    Cancelled,

113

114

115

impl From<StatusToDo> for Status {

116

12

    fn from(status: StatusToDo) -> Self {

117

12

        match status {

118

            StatusToDo::NeedsAction => Status::NeedsAction,

119

            StatusToDo::Completed => Status::Completed,

120

12

            StatusToDo::InProcess => Status::InProcess,

121

            StatusToDo::Cancelled => Status::Cancelled,

122

123

12

124

125

126

pub enum StatusJournal {

127

    Draft,

128

    Final,

129

    Cancelled,

130

131

132

impl From<StatusJournal> for Status {

133

12

    fn from(status: StatusJournal) -> Self {

134

12

        match status {

135

12

            StatusJournal::Draft => Status::Draft,

136

            StatusJournal::Final => Status::Final,

137

            StatusJournal::Cancelled => Status::Cancelled,

138

139

12

140

141

142

macro_rules! impl_finish_property_build {

143

    ($ev:expr) => {

144

72

        pub fn finish_property(mut self) -> ICalObjectBuilder {

145

72

            self.owner.inner.properties.push($ev(self.inner));

146

72

            self.owner

147

72

148

};

149

150

151

macro_rules! impl_finish_component_property_build {

152

    ($ev:expr) => {

153

686

        pub fn finish_property(mut self) -> P {

154

686

            self.owner.add_property($ev(self.inner));

155

686

            self.owner

156

686

157

};

158

159

160

#[derive(Debug, PartialEq)]

161

pub enum CalendarProperty {

162

    ProductId(ProductIdProperty),

163

    Version(VersionProperty),

164

    CalendarScale(CalendarScaleProperty),

165

    Method(MethodProperty),

166

    XProperty(XProperty),

167

    IanaProperty(IanaProperty),

168

169

170

#[derive(Debug, PartialEq)]

171

pub struct ProductIdProperty {

172

    pub(crate) value: String,

173

    pub(crate) params: Vec<Param>,

174

175

176

pub struct ProductIdPropertyBuilder {

177

    owner: ICalObjectBuilder,

178

    inner: ProductIdProperty,

179

180

181

impl ProductIdPropertyBuilder {

182

22

    pub(crate) fn new(owner: ICalObjectBuilder, value: String) -> ProductIdPropertyBuilder {

183

22

        ProductIdPropertyBuilder {

184

22

            owner,

185

22

            inner: ProductIdProperty {

186

22

                value,

187

22

                params: Vec::new(),

188

22

},

189

22

190

22

191

192

    impl_finish_property_build!(CalendarProperty::ProductId);

193

194

195

impl_other_params_builder!(ProductIdPropertyBuilder);

196

197

#[derive(Debug, PartialEq)]

198

pub struct VersionProperty {

199

    pub(crate) min_version: Option<String>,

200

    pub(crate) max_version: String,

201

    pub(crate) params: Vec<Param>,

202

203

204

pub struct VersionPropertyBuilder {

205

    owner: ICalObjectBuilder,

206

    inner: VersionProperty,

207

208

209

impl VersionPropertyBuilder {

210

18

    pub(crate) fn new(

211

18

        owner: ICalObjectBuilder,

212

18

        min_version: Option<String>,

213

18

        max_version: String,

214

18

    ) -> VersionPropertyBuilder {

215

18

        VersionPropertyBuilder {

216

18

            owner,

217

18

            inner: VersionProperty {

218

18

                min_version,

219

18

                max_version,

220

18

                params: Vec::new(),

221

18

},

222

18

223

18

224

225

    impl_finish_property_build!(CalendarProperty::Version);

226

227

228

impl_other_params_builder!(VersionPropertyBuilder);

229

230

#[derive(Debug, PartialEq)]

231

pub struct CalendarScaleProperty {

232

    pub(crate) value: String,

233

    pub(crate) params: Vec<Param>,

234

235

236

pub struct CalendarScalePropertyBuilder {

237

    owner: ICalObjectBuilder,

238

    inner: CalendarScaleProperty,

239

240

241

impl CalendarScalePropertyBuilder {

242

14

    pub(crate) fn new(owner: ICalObjectBuilder, value: String) -> CalendarScalePropertyBuilder {

243

14

        CalendarScalePropertyBuilder {

244

14

            owner,

245

14

            inner: CalendarScaleProperty {

246

14

                value,

247

14

                params: Vec::new(),

248

14

},

249

14

250

14

251

252

    impl_finish_property_build!(CalendarProperty::CalendarScale);

253

254

255

impl_other_params_builder!(CalendarScalePropertyBuilder);

256

257

#[derive(Debug, PartialEq)]

258

pub struct MethodProperty {

259

    pub(crate) value: String,

260

    pub(crate) params: Vec<Param>,

261

262

263

pub struct MethodPropertyBuilder {

264

    owner: ICalObjectBuilder,

265

    inner: MethodProperty,

266

267

268

impl MethodPropertyBuilder {

269

14

    pub(crate) fn new(owner: ICalObjectBuilder, value: String) -> MethodPropertyBuilder {

270

14

        MethodPropertyBuilder {

271

14

            owner,

272

14

            inner: MethodProperty {

273

14

                params: Vec::new(),

274

14

                value,

275

14

},

276

14

277

14

278

279

    impl_finish_property_build!(CalendarProperty::Method);

280

281

282

impl_other_params_builder!(MethodPropertyBuilder);

283

284

#[derive(Debug, PartialEq)]

285

pub enum ComponentProperty {

286

    /// RFC 5545, 3.8.1.1

287

    /// Value type: URI or BINARY

288

    Attach(AttachProperty),

289

    /// RFC 5545, 3.8.1.2

290

    /// Value type: TEXT

291

    Categories(CategoriesProperty),

292

    /// RFC 5545, 3.8.1.3

293

    /// Value type: TEXT

294

    Classification(ClassificationProperty),

295

    /// RFC 5545, 3.8.1.4

296

    /// Value type: TEXT

297

    Comment(CommentProperty),

298

    /// RFC 5545, 3.8.1.5

299

    /// Value type: TEXT

300

    Description(DescriptionProperty),

301

    /// RFC 5545, 3.8.1.6

302

    /// Value type: FLOAT

303

    GeographicPosition(GeographicPositionProperty),

304

    /// RFC 5545, 3.8.1.7

305

    /// Value type: TEXT

306

    Location(LocationProperty),

307

    /// RFC 5545, 4.8.1.8

308

    /// Value type: INTEGER

309

    PercentComplete(PercentCompleteProperty),

310

    /// RFC 5545, 3.8.1.9

311

    /// Value type: INTEGER

312

    Priority(PriorityProperty),

313

    /// RFC 5545, 3.8.1.10

314

    /// Value type: TEXT

315

    Resources(ResourcesProperty),

316

    /// RFC 5545, 3.8.1.11

317

    /// Value type: TEXT

318

    Status(StatusProperty),

319

    /// RFC 5545, 3.8.1.12

320

    /// Value type: TEXT

321

    Summary(SummaryProperty),

322

    /// RFC 5545, 3.8.2.1

323

    /// Value type: DATE-TIME

324

    DateTimeCompleted(DateTimeCompletedProperty),

325

    /// RFC 5545, 3.8.2.2

326

    /// Value type: DATE-TIME or DATE

327

    DateTimeEnd(DateTimeEndProperty),

328

    /// RFC 5545, 3.8.2.3

329

    /// Value type: DATE-TIME or DATE

330

    DateTimeDue(DateTimeDueProperty),

331

    /// RFC 5545, 3.8.2.4

332

    /// Value type: DATE-TIME or DATE

333

    DateTimeStart(DateTimeStartProperty),

334

    /// RFC 5545, 3.8.2.5

335

    /// Value type: DURATION

336

    Duration(DurationProperty),

337

    /// RFC 5545, 3.8.2.6

338

    /// Value type: PERIOD

339

    FreeBusyTime(FreeBusyTimeProperty),

340

    /// RFC 5545, 3.8.2.7

341

    /// Value type: TEXT

342

    TimeTransparency(TimeTransparencyProperty),

343

    /// RFC 5545, 3.8.3.1

344

    /// Value type: TEXT

345

    TimeZoneId(TimeZoneIdProperty),

346

    /// RFC 5545, 3.8.3.2

347

    /// Value type: TEXT

348

    TimeZoneName(TimeZoneNameProperty),

349

    /// RFC 5545, 3.8.3.3

350

    /// Value type: UTC-OFFSET

351

    TimeZoneOffsetFrom(TimeZoneOffsetFromProperty),

352

    /// RFC 5545, 3.8.3.4

353

    /// Value type: UTC-OFFSET

354

    TimeZoneOffsetTo(TimeZoneOffsetToProperty),

355

    /// RFC 5545, 3.8.3.5

356

    /// Value type: URI

357

    TimeZoneUrl(TimeZoneUrlProperty),

358

    /// RFC 5545, 3.8.4.1

359

    /// Value type: CAL-ADDRESS

360

    Attendee(AttendeeProperty),

361

    /// RFC 5545, 3.8.4.2

362

    /// Value type: TEXT

363

    Contact(ContactProperty),

364

    /// RFC 5545, 3.8.4.3

365

    /// Value type: CAL-ADDRESS

366

    Organizer(OrganizerProperty),

367

    /// RFC 5545, 3.8.4.4

368

    /// Value type: DATE-TIME or DATE

369

    RecurrenceId(RecurrenceIdProperty),

370

    /// RFC 5545, 3.8.4.5

371

    /// Value type: TEXT

372

    RelatedTo(RelatedToProperty),

373

    /// RFC 5545, 3.8.4.6

374

    /// Value type: URI

375

    Url(UrlProperty),

376

    /// RFC 5545, 3.8.4.7

377

    /// Value type: TEXT

378

    UniqueIdentifier(UniqueIdentifierProperty),

379

    /// RFC 5545, 3.8.5.1

380

    /// Value type: DATE-TIME or DATE

381

    ExceptionDateTimes(ExceptionDateTimesProperty),

382

    /// RFC 5545, 3.8.5.2

383

    /// Value type: DATE-TIME or DATE or PERIOD

384

    RecurrenceDateTimes(RecurrenceDateTimesProperty),

385

    /// RFC 5545, 3.8.5.3

386

    /// Value type: RECUR

387

    RecurrenceRule(RecurrenceRuleProperty),

388

    /// RFC 5545, 3.8.6.1

389

    /// Value type: TEXT

390

    Action(ActionProperty),

391

    /// RFC 5545, 3.8.6.2

392

    /// Value type: INTEGER

393

    Repeat(RepeatProperty),

394

    /// RFC 5545, 3.8.6.3

395

    /// Value type: DURATION or DATE-TIME

396

    Trigger(TriggerProperty),

397

    /// RFC 5545, 3.8.7.1

398

    /// Value type: DATE-TIME

399

    DateTimeCreated(CreatedProperty),

400

    /// RFC 5545, 3.8.7.2

401

    /// Value type: DATE-TIME

402

    DateTimeStamp(DateTimeStampProperty),

403

    /// RFC 5545, 3.8.7.3

404

    /// Value type: DATE-TIME

405

    LastModified(LastModifiedProperty),

406

    /// RFC 5545, 3.8.7.4

407

    /// Value type: INTEGER

408

    Sequence(SequenceProperty),

409

    /// RFC 5545, 3.8.8.1

410

    /// Value type: TEXT or any other type

411

    IanaProperty(IanaProperty),

412

    /// RFC 5545, 3.8.8.2

413

    /// Value type: TEXT or any other type

414

    XProperty(XProperty),

415

    /// RFC 5545, 3.8.8.3

416

    /// Value type: TEXT

417

    RequestStatus(RequestStatusProperty),

418

419

420

impl ComponentProperty {

421

2280

    pub fn params(&self) -> &[Param] {

422

2280

        match self {

423

158

            ComponentProperty::DateTimeStamp(p) => &p.params,

424

158

            ComponentProperty::UniqueIdentifier(p) => &p.params,

425

170

            ComponentProperty::DateTimeStart(p) => &p.params,

426

36

            ComponentProperty::Classification(p) => &p.params,

427

36

            ComponentProperty::DateTimeCreated(p) => &p.params,

428

96

            ComponentProperty::Description(p) => &p.params,

429

20

            ComponentProperty::GeographicPosition(p) => &p.params,

430

42

            ComponentProperty::LastModified(p) => &p.params,

431

26

            ComponentProperty::Location(p) => &p.params,

432

48

            ComponentProperty::Organizer(p) => &p.params,

433

20

            ComponentProperty::Priority(p) => &p.params,

434

30

            ComponentProperty::Sequence(p) => &p.params,

435

48

            ComponentProperty::Summary(p) => &p.params,

436

10

            ComponentProperty::TimeTransparency(p) => &p.params,

437

24

            ComponentProperty::RequestStatus(p) => &p.params,

438

40

            ComponentProperty::Url(p) => &p.params,

439

30

            ComponentProperty::RecurrenceId(p) => &p.params,

440

176

            ComponentProperty::RecurrenceRule(p) => &p.params,

441

44

            ComponentProperty::DateTimeEnd(p) => &p.params,

442

62

            ComponentProperty::Duration(p) => &p.params,

443

54

            ComponentProperty::Attach(p) => &p.params,

444

40

            ComponentProperty::Attendee(p) => &p.params,

445

24

            ComponentProperty::Categories(p) => &p.params,

446

36

            ComponentProperty::Comment(p) => &p.params,

447

28

            ComponentProperty::Contact(p) => &p.params,

448

20

            ComponentProperty::ExceptionDateTimes(p) => &p.params,

449

30

            ComponentProperty::Status(p) => &p.params,

450

18

            ComponentProperty::RelatedTo(p) => &p.params,

451

12

            ComponentProperty::Resources(p) => &p.params,

452

64

            ComponentProperty::RecurrenceDateTimes(p) => &p.params,

453

6

            ComponentProperty::DateTimeCompleted(p) => &p.params,

454

10

            ComponentProperty::PercentComplete(p) => &p.params,

455

10

            ComponentProperty::DateTimeDue(p) => &p.params,

456

6

            ComponentProperty::FreeBusyTime(p) => &p.params,

457

26

            ComponentProperty::TimeZoneId(p) => &p.params,

458

10

            ComponentProperty::TimeZoneUrl(p) => &p.params,

459

40

            ComponentProperty::TimeZoneOffsetTo(p) => &p.params,

460

40

            ComponentProperty::TimeZoneOffsetFrom(p) => &p.params,

461

30

            ComponentProperty::TimeZoneName(p) => &p.params,

462

52

            ComponentProperty::Action(p) => &p.params,

463

92

            ComponentProperty::Trigger(p) => &p.params,

464

42

            ComponentProperty::Repeat(p) => &p.params,

465

168

            ComponentProperty::IanaProperty(p) => &p.params,

466

148

            ComponentProperty::XProperty(p) => &p.params,

467

468

2280

469

470

471

pub trait ComponentPropertyInner<T> {

472

    fn property_inner(&self) -> Option<&T>;

473

474

475

macro_rules! impl_component_property_inner {

476

    ($for_type:ty, $variant:ident) => {

477

        impl $crate::model::property::ComponentPropertyInner<$for_type>

478

            for $crate::model::property::ComponentProperty

479

480

114

            fn property_inner(&self) -> Option<&$for_type> {

481

114

                match self {

482

48

                    $crate::model::property::ComponentProperty::$variant(p) => Some(p),

483

66

                    _ => None,

484

485

114

486

487

};

488

489

490

impl_component_property_inner!(ClassificationProperty, Classification);

491

impl_component_property_inner!(DescriptionProperty, Description);

492

impl_component_property_inner!(GeographicPositionProperty, GeographicPosition);

493

impl_component_property_inner!(LocationProperty, Location);

494

impl_component_property_inner!(PercentCompleteProperty, PercentComplete);

495

impl_component_property_inner!(PriorityProperty, Priority);

496

impl_component_property_inner!(StatusProperty, Status);

497

impl_component_property_inner!(SummaryProperty, Summary);

498

impl_component_property_inner!(DateTimeCompletedProperty, DateTimeCompleted);

499

impl_component_property_inner!(DateTimeEndProperty, DateTimeEnd);

500

impl_component_property_inner!(DateTimeDueProperty, DateTimeDue);

501

impl_component_property_inner!(DateTimeStartProperty, DateTimeStart);

502

impl_component_property_inner!(DurationProperty, Duration);

503

impl_component_property_inner!(TimeTransparencyProperty, TimeTransparency);

504

impl_component_property_inner!(TimeZoneIdProperty, TimeZoneId);

505

impl_component_property_inner!(TimeZoneOffsetFromProperty, TimeZoneOffsetFrom);

506

impl_component_property_inner!(TimeZoneOffsetToProperty, TimeZoneOffsetTo);

507

impl_component_property_inner!(TimeZoneUrlProperty, TimeZoneUrl);

508

impl_component_property_inner!(OrganizerProperty, Organizer);

509

impl_component_property_inner!(RecurrenceIdProperty, RecurrenceId);

510

impl_component_property_inner!(UrlProperty, Url);

511

impl_component_property_inner!(UniqueIdentifierProperty, UniqueIdentifier);

512

impl_component_property_inner!(RecurrenceRuleProperty, RecurrenceRule);

513

impl_component_property_inner!(ActionProperty, Action);

514

impl_component_property_inner!(RepeatProperty, Repeat);

515

impl_component_property_inner!(TriggerProperty, Trigger);

516

impl_component_property_inner!(CreatedProperty, DateTimeCreated);

517

impl_component_property_inner!(DateTimeStampProperty, DateTimeStamp);

518

impl_component_property_inner!(LastModifiedProperty, LastModified);

519

impl_component_property_inner!(SequenceProperty, Sequence);

520

impl_component_property_inner!(ContactProperty, Contact);

521

impl_component_property_inner!(AttachProperty, Attach);

522

523

pub trait ComponentPropertiesInner<T> {

524

    fn many_property_inner(&self) -> Option<&T>;

525

526

527

macro_rules! impl_component_properties_inner {

528

    ($for_type:ty, $variant:ident) => {

529

        impl $crate::model::property::ComponentPropertiesInner<$for_type>

530

            for $crate::model::property::ComponentProperty

531

532

312

            fn many_property_inner(&self) -> Option<&$for_type> {

533

312

                match self {

534

18

                    $crate::model::property::ComponentProperty::$variant(p) => Some(p),

535

294

                    _ => None,

536

537

312

538

539

};

540

541

542

impl_component_properties_inner!(AttachProperty, Attach);

543

impl_component_properties_inner!(CategoriesProperty, Categories);

544

impl_component_properties_inner!(AttendeeProperty, Attendee);

545

impl_component_properties_inner!(RecurrenceRuleProperty, RecurrenceRule);

546

impl_component_properties_inner!(CommentProperty, Comment);

547

impl_component_properties_inner!(ContactProperty, Contact);

548

impl_component_properties_inner!(ExceptionDateTimesProperty, ExceptionDateTimes);

549

impl_component_properties_inner!(RecurrenceDateTimesProperty, RecurrenceDateTimes);

550

impl_component_properties_inner!(RequestStatusProperty, RequestStatus);

551

impl_component_properties_inner!(RelatedToProperty, RelatedTo);

552

impl_component_properties_inner!(ResourcesProperty, Resources);

553

impl_component_properties_inner!(DescriptionProperty, Description);

554

impl_component_properties_inner!(FreeBusyTimeProperty, FreeBusyTime);

555

impl_component_properties_inner!(TimeZoneNameProperty, TimeZoneName);

556

557

#[derive(Debug, PartialEq)]

558

pub struct TriggerProperty {

559

    pub(crate) value: TriggerValue,

560

    pub(crate) params: Vec<Param>,

561

562

563

#[derive(Debug, PartialEq)]

564

pub enum TriggerValue {

565

    Relative(Duration),

566

    Absolute(CalendarDateTime),

567

568

569

impl_property_access!(TriggerProperty, TriggerValue);

570

571

#[derive(Debug, PartialEq)]

572

pub struct XProperty {

573

    pub(crate) name: String,

574

    pub(crate) value: String,

575

    pub(crate) params: Vec<Param>,

576

577

578

impl_property_access!(XProperty, String);

579

580

pub struct XPropertyBuilder {

581

    owner: ICalObjectBuilder,

582

    inner: XProperty,

583

584

585

impl XPropertyBuilder {

586

2

    pub(crate) fn new(owner: ICalObjectBuilder, name: String, value: String) -> XPropertyBuilder {

587

2

        XPropertyBuilder {

588

2

            owner,

589

2

            inner: XProperty {

590

2

                name,

591

2

                value,

592

2

                params: Vec::new(),

593

2

},

594

2

595

2

596

597

    impl_finish_property_build!(CalendarProperty::XProperty);

598

599

600

impl_other_params_builder!(XPropertyBuilder);

601

602

#[derive(Debug, PartialEq)]

603

pub struct IanaProperty {

604

    pub(crate) name: String,

605

    pub(crate) value: String,

606

    pub(crate) params: Vec<Param>,

607

608

609

impl_property_access!(IanaProperty, String);

610

611

pub struct IanaPropertyBuilder {

612

    owner: ICalObjectBuilder,

613

    inner: IanaProperty,

614

615

616

impl IanaPropertyBuilder {

617

2

    pub(crate) fn new(

618

2

        owner: ICalObjectBuilder,

619

2

        name: String,

620

2

        value: String,

621

2

    ) -> IanaPropertyBuilder {

622

2

        IanaPropertyBuilder {

623

2

            owner,

624

2

            inner: IanaProperty {

625

2

                name,

626

2

                value,

627

2

                params: Vec::new(),

628

2

},

629

2

630

2

631

632

    impl_finish_property_build!(CalendarProperty::IanaProperty);

633

634

635

impl_other_params_builder!(IanaPropertyBuilder);

636

637

pub struct XComponentPropertyBuilder<P> {

638

    owner: P,

639

    inner: XProperty,

640

641

642

impl<P> XComponentPropertyBuilder<P>

643

where

644

    P: AddComponentProperty,

645

646

56

    pub(crate) fn new(owner: P, name: String, value: String) -> XComponentPropertyBuilder<P> {

647

56

        XComponentPropertyBuilder {

648

56

            owner,

649

56

            inner: XProperty {

650

56

                params: Vec::new(),

651

56

                name,

652

56

                value,

653

56

},

654

56

655

56

656

657

    impl_finish_component_property_build!(ComponentProperty::XProperty);

658

659

660

impl_other_component_params_builder!(XComponentPropertyBuilder<P>);

661

662

pub struct IanaComponentPropertyBuilder<P> {

663

    owner: P,

664

    inner: IanaProperty,

665

666

667

impl<P> IanaComponentPropertyBuilder<P>

668

where

669

    P: AddComponentProperty,

670

671

56

    pub(crate) fn new(owner: P, name: String, value: String) -> IanaComponentPropertyBuilder<P> {

672

56

        IanaComponentPropertyBuilder {

673

56

            owner,

674

56

            inner: IanaProperty {

675

56

                name,

676

56

                value,

677

56

                params: Vec::new(),

678

56

},

679

56

680

56

681

682

    impl_finish_component_property_build!(ComponentProperty::IanaProperty);

683

684

685

impl_other_component_params_builder!(IanaComponentPropertyBuilder<P>);

686

687

#[derive(Debug, PartialEq)]

688

pub struct DateTimeStampProperty {

689

    pub(crate) value: CalendarDateTime,

690

    pub(crate) params: Vec<Param>,

691

692

693

impl_property_access!(DateTimeStampProperty, CalendarDateTime);

694

695

pub struct DateTimeStampPropertyBuilder<P: AddComponentProperty> {

696

    owner: P,

697

    inner: DateTimeStampProperty,

698

699

700

impl<P> DateTimeStampPropertyBuilder<P>

701

where

702

    P: AddComponentProperty,

703

704

50

    pub(crate) fn new(

705

50

        owner: P,

706

50

        date: time::Date,

707

50

        time: time::Time,

708

50

    ) -> DateTimeStampPropertyBuilder<P> {

709

50

        DateTimeStampPropertyBuilder {

710

50

            owner,

711

50

            inner: DateTimeStampProperty {

712

50

                value: (date, time, false).into(),

713

50

                params: Vec::new(),

714

50

},

715

50

716

50

717

718

    add_is_utc!();

719

720

    impl_finish_component_property_build!(ComponentProperty::DateTimeStamp);

721

722

723

impl_other_component_params_builder!(DateTimeStampPropertyBuilder<P>);

724

725

#[derive(Debug, PartialEq)]

726

pub struct UniqueIdentifierProperty {

727

    pub(crate) value: String,

728

    pub(crate) params: Vec<Param>,

729

730

731

impl_property_access!(UniqueIdentifierProperty, String);

732

733

pub struct UniqueIdentifierPropertyBuilder<P: AddComponentProperty> {

734

    owner: P,

735

    inner: UniqueIdentifierProperty,

736

737

738

impl<P> UniqueIdentifierPropertyBuilder<P>

739

where

740

    P: AddComponentProperty,

741

742

18

    pub(crate) fn new(owner: P, value: String) -> UniqueIdentifierPropertyBuilder<P> {

743

18

        UniqueIdentifierPropertyBuilder {

744

18

            owner,

745

18

            inner: UniqueIdentifierProperty {

746

18

                value,

747

18

                params: Vec::new(),

748

18

},

749

18

750

18

751

752

    impl_finish_component_property_build!(ComponentProperty::UniqueIdentifier);

753

754

755

impl_other_component_params_builder!(UniqueIdentifierPropertyBuilder<P>);

756

757

#[derive(Debug, Clone, PartialEq)]

758

pub struct DateTimeStartProperty {

759

    pub(crate) value: CalendarDateTime,

760

    pub(crate) params: Vec<Param>,

761

762

763

impl_property_access!(DateTimeStartProperty, CalendarDateTime);

764

765

pub struct DateTimeStartPropertyBuilder<P: AddComponentProperty> {

766

    owner: P,

767

    inner: DateTimeStartProperty,

768

769

770

impl<P> DateTimeStartPropertyBuilder<P>

771

where

772

    P: AddComponentProperty,

773

774

74

    pub(crate) fn new(

775

74

        owner: P,

776

74

        date: time::Date,

777

74

        time: Option<time::Time>,

778

74

    ) -> DateTimeStartPropertyBuilder<P> {

779

74

        let mut params = Vec::new();

780

74

781

74

        // The default is DATE-TIME. If the time is None, then it is a DATE and although it's

782

74

        // optional, this will default to setting the value here.

783

74

        if time.is_none() {

784

            params.push(Param::ValueType(ValueTypeParam { value: Value::Date }))

785

74

786

787

74

        DateTimeStartPropertyBuilder {

788

74

            owner,

789

74

            inner: DateTimeStartProperty {

790

74

                value: (date, time, false).into(),

791

74

                params,

792

74

},

793

74

794

74

795

796

    tz_id_param!();

797

798

    add_is_utc!();

799

800

    impl_finish_component_property_build!(ComponentProperty::DateTimeStart);

801

802

803

impl_other_component_params_builder!(DateTimeStartPropertyBuilder<P>);

804

805

impl_date_time_query!(DateTimeStartProperty);

806

807

#[derive(Debug, PartialEq)]

808

pub struct ClassificationProperty {

809

    pub(crate) value: Classification,

810

    pub(crate) params: Vec<Param>,

811

812

813

impl_property_access!(ClassificationProperty, Classification);

814

815

pub struct ClassificationPropertyBuilder<P: AddComponentProperty> {

816

    owner: P,

817

    inner: ClassificationProperty,

818

819

820

impl<P> ClassificationPropertyBuilder<P>

821

where

822

    P: AddComponentProperty,

823

824

38

    pub(crate) fn new(owner: P, value: Classification) -> ClassificationPropertyBuilder<P> {

825

38

        ClassificationPropertyBuilder {

826

38

            owner,

827

38

            inner: ClassificationProperty {

828

38

                value,

829

38

                params: Vec::new(),

830

38

},

831

38

832

38

833

834

    impl_finish_component_property_build!(ComponentProperty::Classification);

835

836

837

impl_other_component_params_builder!(ClassificationPropertyBuilder<P>);

838

839

#[derive(Debug, PartialEq)]

840

pub struct CreatedProperty {

841

    pub(crate) value: CalendarDateTime,

842

    pub(crate) params: Vec<Param>,

843

844

845

impl_property_access!(CreatedProperty, CalendarDateTime);

846

847

pub struct CreatedPropertyBuilder<P: AddComponentProperty> {

848

    owner: P,

849

    inner: CreatedProperty,

850

851

852

impl<P> CreatedPropertyBuilder<P>

853

where

854

    P: AddComponentProperty,

855

856

38

    pub(crate) fn new(owner: P, date: time::Date, time: time::Time) -> CreatedPropertyBuilder<P> {

857

38

        CreatedPropertyBuilder {

858

38

            owner,

859

38

            inner: CreatedProperty {

860

38

                value: (date, time, false).into(),

861

38

                params: Vec::new(),

862

38

},

863

38

864

38

865

866

    add_is_utc!();

867

868

    impl_finish_component_property_build!(ComponentProperty::DateTimeCreated);

869

870

871

impl_other_component_params_builder!(CreatedPropertyBuilder<P>);

872

873

#[derive(Debug, PartialEq)]

874

pub struct DescriptionProperty {

875

    pub(crate) value: String,

876

    pub(crate) params: Vec<Param>,

877

878

879

impl_property_access!(DescriptionProperty, String);

880

881

pub struct DescriptionPropertyBuilder<P: AddComponentProperty> {

882

    owner: P,

883

    inner: DescriptionProperty,

884

885

886

impl<P> DescriptionPropertyBuilder<P>

887

where

888

    P: AddComponentProperty,

889

890

26

    pub(crate) fn new(owner: P, value: String) -> DescriptionPropertyBuilder<P> {

891

26

        DescriptionPropertyBuilder {

892

26

            owner,

893

26

            inner: DescriptionProperty {

894

26

                value,

895

26

                params: Vec::new(),

896

26

},

897

26

898

26

899

900

    altrep_param!();

901

    language_param!();

902

903

    impl_finish_component_property_build!(ComponentProperty::Description);

904

905

906

impl_other_component_params_builder!(DescriptionPropertyBuilder<P>);

907

908

#[derive(Debug, PartialEq)]

909

pub struct GeographicPositionProperty {

910

    pub(crate) value: GeographicPositionPropertyValue,

911

    pub(crate) params: Vec<Param>,

912

913

914

#[derive(Debug, PartialEq)]

915

pub struct GeographicPositionPropertyValue {

916

    pub latitude: f64,

917

    pub longitude: f64,

918

919

920

impl_property_access!(GeographicPositionProperty, GeographicPositionPropertyValue);

921

922

pub struct GeographicPositionPropertyBuilder<P: AddComponentProperty> {

923

    owner: P,

924

    inner: GeographicPositionProperty,

925

926

927

impl<P> GeographicPositionPropertyBuilder<P>

928

where

929

    P: AddComponentProperty,

930

931

26

    pub(crate) fn new(

932

26

        owner: P,

933

26

        latitude: f64,

934

26

        longitude: f64,

935

26

    ) -> GeographicPositionPropertyBuilder<P> {

936

26

        GeographicPositionPropertyBuilder {

937

26

            owner,

938

26

            inner: GeographicPositionProperty {

939

26

                value: GeographicPositionPropertyValue {

940

26

                    latitude,

941

26

                    longitude,

942

26

},

943

26

                params: Vec::new(),

944

26

},

945

26

946

26

947

948

    impl_finish_component_property_build!(ComponentProperty::GeographicPosition);

949

950

951

impl_other_component_params_builder!(GeographicPositionPropertyBuilder<P>);

952

953

#[derive(Debug, PartialEq)]

954

pub struct LastModifiedProperty {

955

    pub(crate) value: CalendarDateTime,

956

    pub(crate) params: Vec<Param>,

957

958

959

impl_property_access!(LastModifiedProperty, CalendarDateTime);

960

961

pub struct LastModifiedPropertyBuilder<P: AddComponentProperty> {

962

    owner: P,

963

    inner: LastModifiedProperty,

964

965

966

impl<P> LastModifiedPropertyBuilder<P>

967

where

968

    P: AddComponentProperty,

969

970

50

    pub(crate) fn new(

971

50

        owner: P,

972

50

        date: time::Date,

973

50

        time: time::Time,

974

50

    ) -> LastModifiedPropertyBuilder<P> {

975

50

        LastModifiedPropertyBuilder {

976

50

            owner,

977

50

            inner: LastModifiedProperty {

978

50

                value: (date, time, false).into(),

979

50

                params: Vec::new(),

980

50

},

981

50

982

50

983

984

    add_is_utc!();

985

986

    impl_finish_component_property_build!(ComponentProperty::LastModified);

987

988

989

impl_other_component_params_builder!(LastModifiedPropertyBuilder<P>);

990

991

#[derive(Debug, PartialEq)]

992

pub struct LocationProperty {

993

    pub(crate) value: String,

994

    pub(crate) params: Vec<Param>,

995

996

997

impl_property_access!(LocationProperty, String);

998

999

pub struct LocationPropertyBuilder<P: AddComponentProperty> {

1000

    owner: P,

1001

    inner: LocationProperty,

1002

1003

1004

impl<P> LocationPropertyBuilder<P>

1005

where

1006

    P: AddComponentProperty,

1007

1008

24

    pub(crate) fn new(owner: P, value: String) -> LocationPropertyBuilder<P> {

1009

24

        LocationPropertyBuilder {

1010

24

            owner,

1011

24

            inner: LocationProperty {

1012

24

                value,

1013

24

                params: Vec::new(),

1014

24

},

1015

24

1016

24

1017

1018

    altrep_param!();

1019

    language_param!();

1020

1021

    impl_finish_component_property_build!(ComponentProperty::Location);

1022

1023

1024

impl_other_component_params_builder!(LocationPropertyBuilder<P>);

1025

1026

#[derive(Debug, PartialEq)]

1027

pub struct OrganizerProperty {

1028

    pub(crate) value: String,

1029

    pub(crate) params: Vec<Param>,

1030

1031

1032

impl_property_access!(OrganizerProperty, String);

1033

1034

pub struct OrganizerPropertyBuilder<P: AddComponentProperty> {

1035

    owner: P,

1036

    inner: OrganizerProperty,

1037

1038

1039

impl<P> OrganizerPropertyBuilder<P>

1040

where

1041

    P: AddComponentProperty,

1042

1043

50

    pub(crate) fn new(owner: P, value: String) -> OrganizerPropertyBuilder<P> {

1044

50

        OrganizerPropertyBuilder {

1045

50

            owner,

1046

50

            inner: OrganizerProperty {

1047

50

                value,

1048

50

                params: Vec::new(),

1049

50

},

1050

50

1051

50

1052

1053

    common_name_param!();

1054

1055

    directory_entry_reference_param!();

1056

1057

    sent_by_param!();

1058

1059

    language_param!();

1060

1061

    impl_finish_component_property_build!(ComponentProperty::Organizer);

1062

1063

1064

impl_other_component_params_builder!(OrganizerPropertyBuilder<P>);

1065

1066

#[derive(Debug, PartialEq)]

1067

pub struct PriorityProperty {

1068

    pub(crate) value: u8,

1069

    pub(crate) params: Vec<Param>,

1070

1071

1072

impl_property_access!(PriorityProperty, u8);

1073

1074

pub struct PriorityPropertyBuilder<P: AddComponentProperty> {

1075

    owner: P,

1076

    inner: PriorityProperty,

1077

1078

1079

impl<P> PriorityPropertyBuilder<P>

1080

where

1081

    P: AddComponentProperty,

1082

1083

26

    pub(crate) fn new(owner: P, value: u8) -> PriorityPropertyBuilder<P> {

1084

26

        PriorityPropertyBuilder {

1085

26

            owner,

1086

26

            inner: PriorityProperty {

1087

26

                value,

1088

26

                params: Vec::new(),

1089

26

},

1090

26

1091

26

1092

1093

    impl_finish_component_property_build!(ComponentProperty::Priority);

1094

1095

1096

impl_other_component_params_builder!(PriorityPropertyBuilder<P>);

1097

1098

#[derive(Debug, PartialEq)]

1099

pub struct SequenceProperty {

1100

    pub(crate) value: u32,

1101

    pub(crate) params: Vec<Param>,

1102

1103

1104

impl_property_access!(SequenceProperty, u32);

1105

1106

pub struct SequencePropertyBuilder<P: AddComponentProperty> {

1107

    owner: P,

1108

    inner: SequenceProperty,

1109

1110

1111

impl<P> SequencePropertyBuilder<P>

1112

where

1113

    P: AddComponentProperty,

1114

1115

38

    pub(crate) fn new(owner: P, value: u32) -> SequencePropertyBuilder<P> {

1116

38

        SequencePropertyBuilder {

1117

38

            owner,

1118

38

            inner: SequenceProperty {

1119

38

                value,

1120

38

                params: Vec::new(),

1121

38

},

1122

38

1123

38

1124

1125

    impl_finish_component_property_build!(ComponentProperty::Sequence);

1126

1127

1128

impl_other_component_params_builder!(SequencePropertyBuilder<P>);

1129

1130

#[derive(Debug, PartialEq)]

1131

pub struct RequestStatusProperty {

1132

    pub(crate) value: RequestStatusPropertyValue,

1133

    pub(crate) params: Vec<Param>,

1134

1135

1136

#[derive(Debug, PartialEq)]

1137

pub struct RequestStatusPropertyValue {

1138

    pub(crate) status_code: Vec<u32>,

1139

    pub(crate) description: String,

1140

    pub(crate) exception_data: Option<String>,

1141

1142

1143

impl_property_access!(RequestStatusProperty, RequestStatusPropertyValue);

1144

1145

pub struct RequestStatusPropertyBuilder<P: AddComponentProperty> {

1146

    owner: P,

1147

    inner: RequestStatusProperty,

1148

1149

1150

impl<P> RequestStatusPropertyBuilder<P>

1151

where

1152

    P: AddComponentProperty,

1153

1154

50

    pub(crate) fn new(

1155

50

        owner: P,

1156

50

        status_code: Vec<u32>,

1157

50

        description: String,

1158

50

        exception_data: Option<String>,

1159

50

    ) -> RequestStatusPropertyBuilder<P> {

1160

50

        RequestStatusPropertyBuilder {

1161

50

            owner,

1162

50

            inner: RequestStatusProperty {

1163

50

                value: RequestStatusPropertyValue {

1164

50

                    status_code,

1165

50

                    description,

1166

50

                    exception_data,

1167

50

},

1168

50

                params: Vec::new(),

1169

50

},

1170

50

1171

50

1172

1173

    language_param!();

1174

1175

    impl_finish_component_property_build!(ComponentProperty::RequestStatus);

1176

1177

1178

impl_other_component_params_builder!(RequestStatusPropertyBuilder<P>);

1179

1180

#[derive(Debug, PartialEq)]

1181

pub struct SummaryProperty {

1182

    pub(crate) value: String,

1183

    pub(crate) params: Vec<Param>,

1184

1185

1186

impl_property_access!(SummaryProperty, String);

1187

1188

pub struct SummaryPropertyBuilder<P: AddComponentProperty> {

1189

    owner: P,

1190

    inner: SummaryProperty,

1191

1192

1193

impl<P> SummaryPropertyBuilder<P>

1194

where

1195

    P: AddComponentProperty,

1196

1197

18

    pub(crate) fn new(owner: P, value: String) -> SummaryPropertyBuilder<P> {

1198

18

        SummaryPropertyBuilder {

1199

18

            owner,

1200

18

            inner: SummaryProperty {

1201

18

                value,

1202

18

                params: Vec::new(),

1203

18

},

1204

18

1205

18

1206

1207

    altrep_param!();

1208

    language_param!();

1209

1210

    impl_finish_component_property_build!(ComponentProperty::Summary);

1211

1212

1213

impl_other_component_params_builder!(SummaryPropertyBuilder<P>);

1214

1215

#[derive(Debug, PartialEq)]

1216

pub struct TimeTransparencyProperty {

1217

    pub(crate) value: TimeTransparency,

1218

    pub(crate) params: Vec<Param>,

1219

1220

1221

impl_property_access!(TimeTransparencyProperty, TimeTransparency);

1222

1223

pub struct TimeTransparencyPropertyBuilder<P: AddComponentProperty> {

1224

    owner: P,

1225

    inner: TimeTransparencyProperty,

1226

1227

1228

impl<P> TimeTransparencyPropertyBuilder<P>

1229

where

1230

    P: AddComponentProperty,

1231

1232

14

    pub(crate) fn new(owner: P, value: TimeTransparency) -> TimeTransparencyPropertyBuilder<P> {

1233

14

        TimeTransparencyPropertyBuilder {

1234

14

            owner,

1235

14

            inner: TimeTransparencyProperty {

1236

14

                value,

1237

14

                params: Vec::new(),

1238

14

},

1239

14

1240

14

1241

1242

    impl_finish_component_property_build!(ComponentProperty::TimeTransparency);

1243

1244

1245

impl_other_component_params_builder!(TimeTransparencyPropertyBuilder<P>);

1246

1247

#[derive(Debug, PartialEq)]

1248

pub struct UrlProperty {

1249

    // TODO should be a URI

1250

    pub(crate) value: String,

1251

    pub(crate) params: Vec<Param>,

1252

1253

1254

impl_property_access!(UrlProperty, String);

1255

1256

pub struct UrlPropertyBuilder<P: AddComponentProperty> {

1257

    owner: P,

1258

    inner: UrlProperty,

1259

1260

1261

impl<P> UrlPropertyBuilder<P>

1262

where

1263

    P: AddComponentProperty,

1264

1265

50

    pub(crate) fn new(owner: P, value: String) -> UrlPropertyBuilder<P> {

1266

50

        UrlPropertyBuilder {

1267

50

            owner,

1268

50

            inner: UrlProperty {

1269

50

                value,

1270

50

                params: Vec::new(),

1271

50

},

1272

50

1273

50

1274

1275

    impl_finish_component_property_build!(ComponentProperty::Url);

1276

1277

1278

impl_other_component_params_builder!(UrlPropertyBuilder<P>);

1279

1280

#[derive(Debug, PartialEq)]

1281

pub struct RecurrenceIdProperty {

1282

    pub(crate) value: CalendarDateTime,

1283

    pub(crate) params: Vec<Param>,

1284

1285

1286

impl_property_access!(RecurrenceIdProperty, CalendarDateTime);

1287

1288

pub struct RecurrenceIdPropertyBuilder<P: AddComponentProperty> {

1289

    owner: P,

1290

    inner: RecurrenceIdProperty,

1291

1292

1293

impl<P> RecurrenceIdPropertyBuilder<P>

1294

where

1295

    P: AddComponentProperty,

1296

1297

38

    pub(crate) fn new(

1298

38

        owner: P,

1299

38

        date: time::Date,

1300

38

        time: Option<time::Time>,

1301

38

    ) -> RecurrenceIdPropertyBuilder<P> {

1302

38

        let mut params = Vec::new();

1303

38

1304

38

        // The default is DATE-TIME. If the time is None, then it is a DATE and although it's

1305

38

        // optional, this will default to setting the value here.

1306

38

        if time.is_none() {

1307

2

            params.push(Param::ValueType(ValueTypeParam { value: Value::Date }))

1308

36

1309

1310

38

        RecurrenceIdPropertyBuilder {

1311

38

            owner,

1312

38

            inner: RecurrenceIdProperty {

1313

38

                value: (date, time, false).into(),

1314

38

                params,

1315

38

},

1316

38

1317

38

1318

1319

    tz_id_param!();

1320

1321

    add_is_utc!();

1322

1323

14

    pub fn add_range(mut self, range: Range) -> Self {

1324

14

        self.inner.params.push(Param::Range(RangeParam { range }));

1325

14

        self

1326

14

1327

1328

    impl_finish_component_property_build!(ComponentProperty::RecurrenceId);

1329

1330

1331

impl_other_component_params_builder!(RecurrenceIdPropertyBuilder<P>);

1332

1333

#[derive(Debug, PartialEq)]

1334

pub struct RecurrenceRuleProperty {

1335

    pub(crate) value: RecurrenceRule,

1336

    pub(crate) params: Vec<Param>,

1337

1338

1339

impl_property_access!(RecurrenceRuleProperty, RecurrenceRule);

1340

1341

pub struct RecurrenceRulePropertyBuilder<P: AddComponentProperty> {

1342

    owner: P,

1343

    inner: RecurrenceRuleProperty,

1344

1345

1346

impl<P> RecurrenceRulePropertyBuilder<P>

1347

where

1348

    P: AddComponentProperty,

1349

1350

62

    pub(crate) fn new(owner: P, rule: RecurrenceRule) -> RecurrenceRulePropertyBuilder<P> {

1351

62

        RecurrenceRulePropertyBuilder {

1352

62

            owner,

1353

62

            inner: RecurrenceRuleProperty {

1354

62

                value: rule,

1355

62

                params: Vec::new(),

1356

62

},

1357

62

1358

62

1359

1360

    impl_finish_component_property_build!(ComponentProperty::RecurrenceRule);

1361

1362

1363

impl_other_component_params_builder!(RecurrenceRulePropertyBuilder<P>);

1364

1365

#[derive(Debug, Clone, PartialEq)]

1366

pub struct DateTimeEndProperty {

1367

    pub(crate) value: CalendarDateTime,

1368

    pub(crate) params: Vec<Param>,

1369

1370

1371

impl_property_access!(DateTimeEndProperty, CalendarDateTime);

1372

1373

pub struct DateTimeEndPropertyBuilder<P: AddComponentProperty> {

1374

    owner: P,

1375

    inner: DateTimeEndProperty,

1376

1377

1378

impl<P> DateTimeEndPropertyBuilder<P>

1379

where

1380

    P: AddComponentProperty,

1381

1382

26

    pub(crate) fn new(

1383

26

        owner: P,

1384

26

        date: time::Date,

1385

26

        time: Option<time::Time>,

1386

26

    ) -> DateTimeEndPropertyBuilder<P> {

1387

26

        let mut params = Vec::new();

1388

26

1389

26

        // The default is DATE-TIME. If the time is None, then it is a DATE and although it's

1390

26

        // optional, this will default to setting the value here.

1391

26

        if time.is_none() {

1392

            params.push(Param::ValueType(ValueTypeParam { value: Value::Date }))

1393

26

1394

1395

26

        DateTimeEndPropertyBuilder {

1396

26

            owner,

1397

26

            inner: DateTimeEndProperty {

1398

26

                value: (date, time, false).into(),

1399

26

                params,

1400

26

},

1401

26

1402

26

1403

1404

    add_is_utc!();

1405

1406

    tz_id_param!();

1407

1408

    impl_finish_component_property_build!(ComponentProperty::DateTimeEnd);

1409

1410

1411

impl_other_component_params_builder!(DateTimeEndPropertyBuilder<P>);

1412

1413

#[derive(Debug, PartialEq)]

1414

pub struct DurationProperty {

1415

    pub(crate) value: Duration,

1416

    pub(crate) params: Vec<Param>,

1417

1418

1419

impl_property_access!(DurationProperty, Duration);

1420

1421

pub struct DurationPropertyBuilder<P: AddComponentProperty> {

1422

    owner: P,

1423

    inner: DurationProperty,

1424

1425

1426

impl<P> DurationPropertyBuilder<P>

1427

where

1428

    P: AddComponentProperty,

1429

1430

30

    pub(crate) fn new(owner: P, duration: Duration) -> DurationPropertyBuilder<P> {

1431

30

        DurationPropertyBuilder {

1432

30

            owner,

1433

30

            inner: DurationProperty {

1434

30

                value: duration,

1435

30

                params: Vec::new(),

1436

30

},

1437

30

1438

30

1439

1440

    impl_finish_component_property_build!(ComponentProperty::Duration);

1441

1442

1443

impl_other_component_params_builder!(DurationPropertyBuilder<P>);

1444

1445

#[derive(Debug, PartialEq)]

1446

pub struct AttachProperty {

1447

    pub(crate) value: String,

1448

    pub(crate) params: Vec<Param>,

1449

1450

1451

impl_property_access!(AttachProperty, String);

1452

1453

pub struct AttachPropertyBuilder<P: AddComponentProperty> {

1454

    owner: P,

1455

    inner: AttachProperty,

1456

1457

1458

impl<P> AttachPropertyBuilder<P>

1459

where

1460

    P: AddComponentProperty,

1461

1462

42

    pub(crate) fn new_with_uri(owner: P, uri: String) -> AttachPropertyBuilder<P> {

1463

42

        AttachPropertyBuilder {

1464

42

            owner,

1465

42

            inner: AttachProperty {

1466

42

                value: uri,

1467

42

                params: Vec::new(),

1468

42

},

1469

42

1470

42

1471

1472

4

    pub(crate) fn new_with_binary(owner: P, binary: String) -> AttachPropertyBuilder<P> {

1473

4

        AttachPropertyBuilder {

1474

4

            owner,

1475

4

            inner: AttachProperty {

1476

4

                value: binary,

1477

4

                params: vec![

1478

4

                    Param::Encoding(EncodingParam {

1479

4

                        encoding: Encoding::Base64,

1480

4

}),

1481

4

                    Param::ValueType(ValueTypeParam {

1482

4

                        value: Value::Binary,

1483

4

}),

1484

4

],

1485

4

},

1486

4

1487

4

1488

1489

14

    pub fn add_fmt_type<U: ToString, V: ToString>(

1490

14

        mut self,

1491

14

        type_name: U,

1492

14

        sub_type_name: V,

1493

14

    ) -> Self {

1494

14

        self.inner.params.push(Param::FormatType(FormatTypeParam {

1495

14

            type_name: type_name.to_string(),

1496

14

            sub_type_name: sub_type_name.to_string(),

1497

14

        }));

1498

14

        self

1499

14

1500

1501

    impl_finish_component_property_build!(ComponentProperty::Attach);

1502

1503

1504

impl_other_component_params_builder!(AttachPropertyBuilder<P>);

1505

1506

#[derive(Debug, PartialEq)]

1507

pub struct AttendeeProperty {

1508

    pub(crate) value: String,

1509

    pub(crate) params: Vec<Param>,

1510

1511

1512

impl_property_access!(AttendeeProperty, String);

1513

1514

pub struct AttendeePropertyBuilder<P: AddComponentProperty, PS> {

1515

    owner: P,

1516

    inner: AttendeeProperty,

1517

    _phantom: PhantomData<PS>,

1518

1519

1520

impl<P, PS> AttendeePropertyBuilder<P, PS>

1521

where

1522

    P: AddComponentProperty,

1523

    PS: Into<ParticipationStatusUnknown>,

1524

1525

54

    pub(crate) fn new(owner: P, value: String) -> AttendeePropertyBuilder<P, PS> {

1526

54

        AttendeePropertyBuilder {

1527

54

            owner,

1528

54

            inner: AttendeeProperty {

1529

54

                value,

1530

54

                params: Vec::new(),

1531

54

},

1532

54

            _phantom: PhantomData,

1533

54

1534

54

1535

1536

12

    pub fn add_calendar_user_type(mut self, cu_type: CalendarUserType) -> Self {

1537

12

        self.inner

1538

12

            .params

1539

12

            .push(Param::CalendarUserType(CalendarUserTypeParam { cu_type }));

1540

12

        self

1541

12

1542

1543

14

    pub fn add_members(mut self, members: Vec<&str>) -> Self {

1544

14

        self.inner.params.push(Param::Members(MembersParam {

1545

14

            members: members.into_iter().map(|m| m.to_string()).collect(),

1546

14

        }));

1547

14

        self

1548

14

1549

1550

12

    pub fn add_role(mut self, role: Role) -> Self {

1551

12

        self.inner.params.push(Param::Role(RoleParam { role }));

1552

12

        self

1553

12

1554

1555

14

    pub fn add_participation_status(mut self, status: PS) -> Self {

1556

14

        self.inner

1557

14

            .params

1558

14

            .push(Param::ParticipationStatus(ParticipationStatusParam {

1559

14

                status: status.into(),

1560

14

            }));

1561

14

        self

1562

14

1563

1564

12

    pub fn add_rsvp(mut self) -> Self {

1565

12

        // Default is false, add to set true

1566

12

        self.inner

1567

12

            .params

1568

12

            .push(Param::Rsvp(RsvpParam { rsvp: true }));

1569

12

        self

1570

12

1571

1572

12

    pub fn add_delegated_to(mut self, delegates: Vec<&str>) -> Self {

1573

12

        self.inner.params.push(Param::DelegatedTo(DelegatedToParam {

1574

12

            delegates: delegates.into_iter().map(|d| d.to_string()).collect(),

1575

12

        }));

1576

12

        self

1577

12

1578

1579

12

    pub fn add_delegated_from(mut self, delegators: Vec<&str>) -> Self {

1580

12

        self.inner

1581

12

            .params

1582

12

            .push(Param::DelegatedFrom(DelegatedFromParam {

1583

12

                delegators: delegators.into_iter().map(|d| d.to_string()).collect(),

1584

12

            }));

1585

12

        self

1586

12

1587

1588

    sent_by_param!();

1589

    common_name_param!();

1590

    directory_entry_reference_param!();

1591

    language_param!();

1592

1593

    impl_finish_component_property_build!(ComponentProperty::Attendee);

1594

1595

1596

impl_other_component_params_builder!(AttendeePropertyBuilder<P, PS>);

1597

1598

#[derive(Debug, PartialEq)]

1599

pub struct CategoriesProperty {

1600

    pub(crate) value: Vec<String>,

1601

    pub(crate) params: Vec<Param>,

1602

1603

1604

impl_property_access!(CategoriesProperty, Vec<String>);

1605

1606

pub struct CategoriesPropertyBuilder<P: AddComponentProperty> {

1607

    owner: P,

1608

    inner: CategoriesProperty,

1609

1610

1611

impl<P> CategoriesPropertyBuilder<P>

1612

where

1613

    P: AddComponentProperty,

1614

1615

38

    pub(crate) fn new(owner: P, value: Vec<String>) -> CategoriesPropertyBuilder<P> {

1616

38

        CategoriesPropertyBuilder {

1617

38

            owner,

1618

38

            inner: CategoriesProperty {

1619

38

                value,

1620

38

                params: Vec::new(),

1621

38

},

1622

38

1623

38

1624

1625

    language_param!();

1626

1627

    impl_finish_component_property_build!(ComponentProperty::Categories);

1628

1629

1630

impl_other_component_params_builder!(CategoriesPropertyBuilder<P>);

1631

1632

#[derive(Debug, PartialEq)]

1633

pub struct CommentProperty {

1634

    pub(crate) value: String,

1635

    pub(crate) params: Vec<Param>,

1636

1637

1638

impl_property_access!(CommentProperty, String);

1639

1640

pub struct CommentPropertyBuilder<P: AddComponentProperty> {

1641

    owner: P,

1642

    inner: CommentProperty,

1643

1644

1645

impl<P> CommentPropertyBuilder<P>

1646

where

1647

    P: AddComponentProperty,

1648

1649

26

    pub(crate) fn new(owner: P, value: String) -> CommentPropertyBuilder<P> {

1650

26

        CommentPropertyBuilder {

1651

26

            owner,

1652

26

            inner: CommentProperty {

1653

26

                value,

1654

26

                params: Vec::new(),

1655

26

},

1656

26

1657

26

1658

1659

    altrep_param!();

1660

    language_param!();

1661

1662

    impl_finish_component_property_build!(ComponentProperty::Comment);

1663

1664

1665

impl_other_component_params_builder!(CommentPropertyBuilder<P>);

1666

1667

#[derive(Debug, PartialEq)]

1668

pub struct ContactProperty {

1669

    pub(crate) value: String,

1670

    pub(crate) params: Vec<Param>,

1671

1672

1673

impl_property_access!(ContactProperty, String);

1674

1675

pub struct ContactPropertyBuilder<P: AddComponentProperty> {

1676

    owner: P,

1677

    inner: ContactProperty,

1678

1679

1680

impl<P> ContactPropertyBuilder<P>

1681

where

1682

    P: AddComponentProperty,

1683

1684

18

    pub(crate) fn new(owner: P, value: String) -> ContactPropertyBuilder<P> {

1685

18

        ContactPropertyBuilder {

1686

18

            owner,

1687

18

            inner: ContactProperty {

1688

18

                value,

1689

18

                params: Vec::new(),

1690

18

},

1691

18

1692

18

1693

1694

    altrep_param!();

1695

    language_param!();

1696

1697

    impl_finish_component_property_build!(ComponentProperty::Contact);

1698

1699

1700

impl_other_component_params_builder!(ContactPropertyBuilder<P>);

1701

1702

#[derive(Debug, PartialEq)]

1703

pub struct ExceptionDateTimesProperty {

1704

    pub(crate) value: Vec<CalendarDateTime>,

1705

    pub(crate) params: Vec<Param>,

1706

1707

1708

impl_property_access!(ExceptionDateTimesProperty, Vec<CalendarDateTime>);

1709

1710

pub struct ExceptionDateTimesPropertyBuilder<P: AddComponentProperty> {

1711

    owner: P,

1712

    inner: ExceptionDateTimesProperty,

1713

1714

1715

impl<P> ExceptionDateTimesPropertyBuilder<P>

1716

where

1717

    P: AddComponentProperty,

1718

1719

38

    pub(crate) fn new(owner: P, date_times: Vec<CalendarDateTime>) -> Self {

1720

38

        let mut params = Vec::new();

1721

38

        if date_times.first().map(|dt| dt.is_date()).unwrap_or(false) {

1722

2

            params.push(Param::ValueType(ValueTypeParam { value: Value::Date }));

1723

38

1724

1725

38

        ExceptionDateTimesPropertyBuilder {

1726

38

            owner,

1727

38

            inner: ExceptionDateTimesProperty {

1728

38

                value: date_times,

1729

38

                params,

1730

38

},

1731

38

1732

38

1733

1734

    tz_id_param!();

1735

1736

    impl_finish_component_property_build!(ComponentProperty::ExceptionDateTimes);

1737

1738

1739

impl_other_component_params_builder!(ExceptionDateTimesPropertyBuilder<P>);

1740

1741

#[derive(Debug, PartialEq)]

1742

pub struct StatusProperty {

1743

    pub(crate) value: Status,

1744

    pub(crate) params: Vec<Param>,

1745

1746

1747

impl_property_access!(StatusProperty, Status);

1748

1749

pub struct StatusPropertyBuilder<P: AddComponentProperty> {

1750

    owner: P,

1751

    inner: StatusProperty,

1752

1753

1754

impl<P> StatusPropertyBuilder<P>

1755

where

1756

    P: AddComponentProperty,

1757

1758

38

    pub(crate) fn new(owner: P, value: Status) -> StatusPropertyBuilder<P> {

1759

38

        StatusPropertyBuilder {

1760

38

            owner,

1761

38

            inner: StatusProperty {

1762

38

                value,

1763

38

                params: Vec::new(),

1764

38

},

1765

38

1766

38

1767

1768

    impl_finish_component_property_build!(ComponentProperty::Status);

1769

1770

1771

impl_other_component_params_builder!(StatusPropertyBuilder<P>);

1772

1773

#[derive(Debug, PartialEq)]

1774

pub struct RelatedToProperty {

1775

    pub(crate) value: String,

1776

    pub(crate) params: Vec<Param>,

1777

1778

1779

impl_property_access!(RelatedToProperty, String);

1780

1781

pub struct RelatedToPropertyBuilder<P: AddComponentProperty> {

1782

    owner: P,

1783

    inner: RelatedToProperty,

1784

1785

1786

impl<P> RelatedToPropertyBuilder<P>

1787

where

1788

    P: AddComponentProperty,

1789

1790

38

    pub(crate) fn new(owner: P, value: String) -> RelatedToPropertyBuilder<P> {

1791

38

        RelatedToPropertyBuilder {

1792

38

            owner,

1793

38

            inner: RelatedToProperty {

1794

38

                value,

1795

38

                params: Vec::new(),

1796

38

},

1797

38

1798

38

1799

1800

14

    pub fn add_relationship_type(mut self, relationship_type: RelationshipType) -> Self {

1801

14

        self.inner

1802

14

            .params

1803

14

            .push(Param::RelationshipType(RelationshipTypeParam {

1804

14

                relationship: relationship_type,

1805

14

            }));

1806

14

        self

1807

14

1808

1809

    impl_finish_component_property_build!(ComponentProperty::RelatedTo);

1810

1811

1812

impl_other_component_params_builder!(RelatedToPropertyBuilder<P>);

1813

1814

#[derive(Debug, PartialEq)]

1815

pub struct ResourcesProperty {

1816

    pub(crate) value: Vec<String>,

1817

    pub(crate) params: Vec<Param>,

1818

1819

1820

impl_property_access!(ResourcesProperty, Vec<String>);

1821

1822

pub struct ResourcesPropertyBuilder<P: AddComponentProperty> {

1823

    owner: P,

1824

    inner: ResourcesProperty,

1825

1826

1827

impl<P> ResourcesPropertyBuilder<P>

1828

where

1829

    P: AddComponentProperty,

1830

1831

26

    pub(crate) fn new(owner: P, value: Vec<String>) -> ResourcesPropertyBuilder<P> {

1832

26

        ResourcesPropertyBuilder {

1833

26

            owner,

1834

26

            inner: ResourcesProperty {

1835

26

                value,

1836

26

                params: Vec::new(),

1837

26

},

1838

26

1839

26

1840

1841

    altrep_param!();

1842

    language_param!();

1843

1844

    impl_finish_component_property_build!(ComponentProperty::Resources);

1845

1846

1847

impl_other_component_params_builder!(ResourcesPropertyBuilder<P>);

1848

1849

#[derive(Clone, Debug, PartialEq)]

1850

pub struct Period {

1851

    pub start: (time::Date, time::Time, bool),

1852

    pub end: PeriodEnd,

1853

1854

1855

impl Period {

1856

12

    pub fn new_explicit(

1857

12

        start_date: time::Date,

1858

12

        start_time: time::Time,

1859

12

        end_date: time::Date,

1860

12

        end_time: time::Time,

1861

12

        is_utc: bool,

1862

12

    ) -> Self {

1863

12

        Period {

1864

12

            start: (start_date, start_time, is_utc),

1865

12

            end: PeriodEnd::DateTime((end_date, end_time, is_utc)),

1866

12

1867

12

1868

1869

14

    pub fn new_start(

1870

14

        start_date: time::Date,

1871

14

        start_time: time::Time,

1872

14

        is_utc: bool,

1873

14

        duration: Duration,

1874

14

    ) -> Self {

1875

14

        Period {

1876

14

            start: (start_date, start_time, is_utc),

1877

14

            end: PeriodEnd::Duration(duration),

1878

14

1879

14

1880

1881

12

    pub fn expand(&self) -> AetoliaResult<Option<(CalendarDateTime, CalendarDateTime)>> {

1882

12

        if self.start.2 {

1883

            Ok(Some((

1884

12

                self.start.into(),

1885

12

                match &self.end {

1886

6

                    PeriodEnd::DateTime(end) => (*end).into(),

1887

6

                    PeriodEnd::Duration(duration) => {

1888

6

                        let cdt: CalendarDateTime = self.start.into();

1889

6

                        cdt.add(duration)?

1890

1891

},

1892

)))

1893

        } else {

1894

            Ok(None)

1895

1896

12

1897

1898

1899

#[derive(Clone, Debug, PartialEq)]

1900

pub enum PeriodEnd {

1901

    DateTime((time::Date, time::Time, bool)),

1902

    Duration(Duration),

1903

1904

1905

#[derive(Debug, PartialEq)]

1906

pub struct RecurrenceDateTimesProperty {

1907

    pub(crate) value: RecurrenceDateTimesPropertyValue,

1908

    pub(crate) params: Vec<Param>,

1909

1910

1911

#[derive(Debug, PartialEq)]

1912

pub enum RecurrenceDateTimesPropertyValue {

1913

    DateTimes(Vec<CalendarDateTime>),

1914

    Periods(Vec<Period>),

1915

1916

1917

impl_property_access!(

1918

    RecurrenceDateTimesProperty,

1919

    RecurrenceDateTimesPropertyValue

1920

);

1921

1922

pub struct RecurrenceDateTimesPropertyBuilder<P: AddComponentProperty> {

1923

    owner: P,

1924

    inner: RecurrenceDateTimesProperty,

1925

1926

1927

impl<P> RecurrenceDateTimesPropertyBuilder<P>

1928

where

1929

    P: AddComponentProperty,

1930

1931

60

    pub fn new_date_times(owner: P, date_times: Vec<CalendarDateTime>) -> Self {

1932

60

        let mut params = Vec::new();

1933

60

        if date_times.first().map(|dt| dt.is_date()).unwrap_or(false) {

1934

            params.push(Param::ValueType(ValueTypeParam { value: Value::Date }));

1935

60

1936

1937

60

        RecurrenceDateTimesPropertyBuilder {

1938

60

            owner,

1939

60

            inner: RecurrenceDateTimesProperty {

1940

60

                value: RecurrenceDateTimesPropertyValue::DateTimes(date_times),

1941

60

                params,

1942

60

},

1943

60

1944

60

1945

1946

2

    pub fn new_periods(owner: P, periods: Vec<Period>) -> Self {

1947

2

        RecurrenceDateTimesPropertyBuilder {

1948

2

            owner,

1949

2

            inner: RecurrenceDateTimesProperty {

1950

2

                value: RecurrenceDateTimesPropertyValue::Periods(periods),

1951

2

                params: vec![Param::ValueType(ValueTypeParam {

1952

2

                    value: Value::Period,

1953

2

                })],

1954

2

},

1955

2

1956

2

1957

1958

    tz_id_param!();

1959

1960

    impl_finish_component_property_build!(ComponentProperty::RecurrenceDateTimes);

1961

1962

1963

impl_other_component_params_builder!(RecurrenceDateTimesPropertyBuilder<P>);

1964

1965

#[derive(Debug, PartialEq)]

1966

pub struct DateTimeCompletedProperty {

1967

    pub(crate) value: CalendarDateTime,

1968

    pub(crate) params: Vec<Param>,

1969

1970

1971

impl_property_access!(DateTimeCompletedProperty, CalendarDateTime);

1972

1973

pub struct CompletedPropertyBuilder<P: AddComponentProperty> {

1974

    owner: P,

1975

    inner: DateTimeCompletedProperty,

1976

1977

1978

impl<P> CompletedPropertyBuilder<P>

1979

where

1980

    P: AddComponentProperty,

1981

1982

12

    pub(crate) fn new(owner: P, date: time::Date, time: time::Time) -> CompletedPropertyBuilder<P> {

1983

12

        CompletedPropertyBuilder {

1984

12

            owner,

1985

12

            inner: DateTimeCompletedProperty {

1986

12

                value: (date, time, false).into(),

1987

12

                params: Vec::new(),

1988

12

},

1989

12

1990

12

1991

1992

    add_is_utc!();

1993

1994

    impl_finish_component_property_build!(ComponentProperty::DateTimeCompleted);

1995

1996

1997

impl_other_component_params_builder!(CompletedPropertyBuilder<P>);

1998

1999

#[derive(Debug, PartialEq)]

2000

pub struct PercentCompleteProperty {

2001

    pub(crate) value: u8,

2002

    pub(crate) params: Vec<Param>,

2003

2004

2005

impl_property_access!(PercentCompleteProperty, u8);

2006

2007

pub struct PercentCompletePropertyBuilder<P: AddComponentProperty> {

2008

    owner: P,

2009

    inner: PercentCompleteProperty,

2010

2011

2012

impl<P> PercentCompletePropertyBuilder<P>

2013

where

2014

    P: AddComponentProperty,

2015

2016

12

    pub(crate) fn new(owner: P, value: u8) -> PercentCompletePropertyBuilder<P> {

2017

12

        PercentCompletePropertyBuilder {

2018

12

            owner,

2019

12

            inner: PercentCompleteProperty {

2020

12

                value,

2021

12

                params: Vec::new(),

2022

12

},

2023

12

2024

12

2025

2026

    impl_finish_component_property_build!(ComponentProperty::PercentComplete);

2027

2028

2029

impl_other_component_params_builder!(PercentCompletePropertyBuilder<P>);

2030

2031

#[derive(Debug, Clone, PartialEq)]

2032

pub struct DateTimeDueProperty {

2033

    pub(crate) value: CalendarDateTime,

2034

    pub(crate) params: Vec<Param>,

2035

2036

2037

impl_property_access!(DateTimeDueProperty, CalendarDateTime);

2038

2039

pub struct DateTimeDuePropertyBuilder<P: AddComponentProperty> {

2040

    owner: P,

2041

    inner: DateTimeDueProperty,

2042

2043

2044

impl<P> DateTimeDuePropertyBuilder<P>

2045

where

2046

    P: AddComponentProperty,

2047

2048

    pub(crate) fn new(

2049

        owner: P,

2050

        date: time::Date,

2051

        time: Option<time::Time>,

2052

    ) -> DateTimeDuePropertyBuilder<P> {

2053

        let mut params = Vec::new();

2054

2055

        // The default is DATE-TIME. If the time is None, then it is a DATE and although it's

2056

        // optional, this will default to setting the value here.

2057

        if time.is_none() {

2058

            params.push(Param::ValueType(ValueTypeParam { value: Value::Date }))

2059

2060

2061

        DateTimeDuePropertyBuilder {

2062

            owner,

2063

            inner: DateTimeDueProperty {

2064

                value: (date, time, false).into(),

2065

                params,

2066

},

2067

2068

2069

2070

    tz_id_param!();

2071

2072

    add_is_utc!();

2073

2074

    impl_finish_component_property_build!(ComponentProperty::DateTimeDue);

2075

2076

2077

impl_other_component_params_builder!(DateTimeDuePropertyBuilder<P>);

2078

2079

#[derive(Debug, PartialEq)]

2080

pub struct FreeBusyTimeProperty {

2081

    pub(crate) value: Vec<Period>,

2082

    pub(crate) params: Vec<Param>,

2083

2084

2085

impl_property_access!(FreeBusyTimeProperty, Vec<Period>);

2086

2087

pub struct FreeBusyTimePropertyBuilder<P: AddComponentProperty> {

2088

    owner: P,

2089

    inner: FreeBusyTimeProperty,

2090

2091

2092

impl<P> FreeBusyTimePropertyBuilder<P>

2093

where

2094

    P: AddComponentProperty,

2095

2096

12

    pub(crate) fn new(

2097

12

        owner: P,

2098

12

        free_busy_time_type: FreeBusyTimeType,

2099

12

        value: Vec<Period>,

2100

12

    ) -> FreeBusyTimePropertyBuilder<P> {

2101

12

        FreeBusyTimePropertyBuilder {

2102

12

            owner,

2103

12

            inner: FreeBusyTimeProperty {

2104

12

                value,

2105

12

                params: vec![Param::FreeBusyTimeType(FreeBusyTimeTypeParam {

2106

12

                    fb_type: free_busy_time_type,

2107

12

                })],

2108

12

},

2109

12

2110

12

2111

2112

    impl_finish_component_property_build!(ComponentProperty::FreeBusyTime);

2113

2114

2115

impl_other_component_params_builder!(FreeBusyTimePropertyBuilder<P>);

2116

2117

#[derive(Debug, PartialEq)]

2118

pub struct TimeZoneIdProperty {

2119

    pub(crate) value: TimeZoneIdPropertyValue,

2120

    pub(crate) params: Vec<Param>,

2121

2122

2123

#[derive(Debug, Clone, PartialEq)]

2124

pub struct TimeZoneIdPropertyValue {

2125

    pub id: String,

2126

    pub unique_registry_id: bool,

2127

2128

2129

impl_property_access!(TimeZoneIdProperty, TimeZoneIdPropertyValue);

2130

2131

pub struct TimeZoneIdPropertyBuilder<P: AddComponentProperty> {

2132

    owner: P,

2133

    inner: TimeZoneIdProperty,

2134

2135

2136

impl<P> TimeZoneIdPropertyBuilder<P>

2137

where

2138

    P: AddComponentProperty,

2139

2140

12

    pub(crate) fn new(

2141

12

        owner: P,

2142

12

        value: String,

2143

12

        unique_registry_id: bool,

2144

12

    ) -> TimeZoneIdPropertyBuilder<P> {

2145

12

        TimeZoneIdPropertyBuilder {

2146

12

            owner,

2147

12

            inner: TimeZoneIdProperty {

2148

12

                value: TimeZoneIdPropertyValue {

2149

12

                    id: value,

2150

12

                    unique_registry_id,

2151

12

},

2152

12

                params: Vec::new(),

2153

12

},

2154

12

2155

12

2156

2157

    impl_finish_component_property_build!(ComponentProperty::TimeZoneId);

2158

2159

2160

impl_other_component_params_builder!(TimeZoneIdPropertyBuilder<P>);

2161

2162

#[derive(Debug, PartialEq)]

2163

pub struct TimeZoneUrlProperty {

2164

    pub(crate) value: String,

2165

    pub(crate) params: Vec<Param>,

2166

2167

2168

impl_property_access!(TimeZoneUrlProperty, String);

2169

2170

pub struct TimeZoneUrlPropertyBuilder<P: AddComponentProperty> {

2171

    owner: P,

2172

    inner: TimeZoneUrlProperty,

2173

2174

2175

impl<P> TimeZoneUrlPropertyBuilder<P>

2176

where

2177

    P: AddComponentProperty,

2178

2179

12

    pub(crate) fn new(owner: P, value: String) -> TimeZoneUrlPropertyBuilder<P> {

2180

12

        TimeZoneUrlPropertyBuilder {

2181

12

            owner,

2182

12

            inner: TimeZoneUrlProperty {

2183

12

                value,

2184

12

                params: Vec::new(),

2185

12

},

2186

12

2187

12

2188

2189

    impl_finish_component_property_build!(ComponentProperty::TimeZoneUrl);

2190

2191

2192

impl_other_component_params_builder!(TimeZoneUrlPropertyBuilder<P>);

2193

2194

#[derive(Debug, PartialEq)]

2195

pub struct TimeZoneOffset {

2196

    pub(crate) sign: i8,

2197

    pub(crate) hours: u8,

2198

    pub(crate) minutes: u8,

2199

    pub(crate) seconds: Option<u8>,

2200

2201

2202

impl TimeZoneOffset {

2203

48

    pub fn new(sign: i8, hours: u8, minutes: u8, seconds: Option<u8>) -> Self {

2204

48

        TimeZoneOffset {

2205

48

            sign,

2206

48

            hours,

2207

48

            minutes,

2208

48

            seconds,

2209

48

2210

48

2211

2212

2213

#[derive(Debug, PartialEq)]

2214

pub struct TimeZoneOffsetToProperty {

2215

    pub(crate) value: TimeZoneOffset,

2216

    pub(crate) params: Vec<Param>,

2217

2218

2219

impl_property_access!(TimeZoneOffsetToProperty, TimeZoneOffset);

2220

2221

pub struct TimeZoneOffsetToPropertyBuilder<P: AddComponentProperty> {

2222

    owner: P,

2223

    inner: TimeZoneOffsetToProperty,

2224

2225

2226

impl<P> TimeZoneOffsetToPropertyBuilder<P>

2227

where

2228

    P: AddComponentProperty,

2229

2230

24

    pub(crate) fn new(owner: P, offset: TimeZoneOffset) -> TimeZoneOffsetToPropertyBuilder<P> {

2231

24

        TimeZoneOffsetToPropertyBuilder {

2232

24

            owner,

2233

24

            inner: TimeZoneOffsetToProperty {

2234

24

                value: offset,

2235

24

                params: Vec::new(),

2236

24

},

2237

24

2238

24

2239

2240

    impl_finish_component_property_build!(ComponentProperty::TimeZoneOffsetTo);

2241

2242

2243

impl_other_component_params_builder!(TimeZoneOffsetToPropertyBuilder<P>);

2244

2245

#[derive(Debug, PartialEq)]

2246

pub struct TimeZoneOffsetFromProperty {

2247

    pub(crate) value: TimeZoneOffset,

2248

    pub(crate) params: Vec<Param>,

2249

2250

2251

impl_property_access!(TimeZoneOffsetFromProperty, TimeZoneOffset);

2252

2253

pub struct TimeZoneOffsetFromPropertyBuilder<P: AddComponentProperty> {

2254

    owner: P,

2255

    inner: TimeZoneOffsetFromProperty,

2256

2257

2258

impl<P> TimeZoneOffsetFromPropertyBuilder<P>

2259

where

2260

    P: AddComponentProperty,

2261

2262

24

    pub(crate) fn new(owner: P, offset: TimeZoneOffset) -> TimeZoneOffsetFromPropertyBuilder<P> {

2263

24

        TimeZoneOffsetFromPropertyBuilder {

2264

24

            owner,

2265

24

            inner: TimeZoneOffsetFromProperty {

2266

24

                value: offset,

2267

24

                params: Vec::new(),

2268

24

},

2269

24

2270

24

2271

2272

    impl_finish_component_property_build!(ComponentProperty::TimeZoneOffsetFrom);

2273

2274

2275

impl_other_component_params_builder!(TimeZoneOffsetFromPropertyBuilder<P>);

2276

2277

#[derive(Debug, PartialEq)]

2278

pub struct TimeZoneNameProperty {

2279

    pub(crate) value: String,

2280

    pub(crate) params: Vec<Param>,

2281

2282

2283

impl_property_access!(TimeZoneNameProperty, String);

2284

2285

pub struct TimeZoneNamePropertyBuilder<P: AddComponentProperty> {

2286

    owner: P,

2287

    inner: TimeZoneNameProperty,

2288

2289

2290

impl<P> TimeZoneNamePropertyBuilder<P>

2291

where

2292

    P: AddComponentProperty,

2293

2294

24

    pub(crate) fn new(owner: P, value: String) -> TimeZoneNamePropertyBuilder<P> {

2295

24

        TimeZoneNamePropertyBuilder {

2296

24

            owner,

2297

24

            inner: TimeZoneNameProperty {

2298

24

                value,

2299

24

                params: Vec::new(),

2300

24

},

2301

24

2302

24

2303

2304

    language_param!();

2305

2306

    impl_finish_component_property_build!(ComponentProperty::TimeZoneName);

2307

2308

2309

impl_other_component_params_builder!(TimeZoneNamePropertyBuilder<P>);

2310

2311

#[derive(Debug, Clone, PartialEq)]

2312

pub enum Action {

2313

    Audio,

2314

    Display,

2315

    Email,

2316

    XName(String),

2317

    IanaToken(String),

2318

2319

2320

#[derive(Debug, PartialEq)]

2321

pub struct ActionProperty {

2322

    pub(crate) value: Action,

2323

    pub(crate) params: Vec<Param>,

2324

2325

2326

impl_property_access!(ActionProperty, Action);

2327

2328

pub struct ActionPropertyBuilder<P: AddComponentProperty> {

2329

    owner: P,

2330

    inner: ActionProperty,

2331

2332

2333

impl<P> ActionPropertyBuilder<P>

2334

where

2335

    P: AddComponentProperty,

2336

2337

16

    pub(crate) fn new(owner: P, value: Action) -> ActionPropertyBuilder<P> {

2338

16

        ActionPropertyBuilder {

2339

16

            owner,

2340

16

            inner: ActionProperty {

2341

16

                value,

2342

16

                params: Vec::new(),

2343

16

},

2344

16

2345

16

2346

2347

    impl_finish_component_property_build!(ComponentProperty::Action);

2348

2349

2350

impl_other_component_params_builder!(ActionPropertyBuilder<P>);

2351

2352

#[derive(Debug)]

2353

pub struct RelativeTriggerProperty {

2354

    pub(crate) value: Duration,

2355

    pub(crate) params: Vec<Param>,

2356

2357

2358

pub struct RelativeTriggerPropertyBuilder<P: AddComponentProperty> {

2359

    owner: P,

2360

    inner: RelativeTriggerProperty,

2361

2362

2363

impl<P> RelativeTriggerPropertyBuilder<P>

2364

where

2365

    P: AddComponentProperty,

2366

2367

8

    pub(crate) fn new(owner: P, value: Duration) -> RelativeTriggerPropertyBuilder<P> {

2368

8

        RelativeTriggerPropertyBuilder {

2369

8

            owner,

2370

8

            inner: RelativeTriggerProperty {

2371

8

                value,

2372

8

                params: Vec::new(),

2373

8

},

2374

8

2375

8

2376

2377

4

    pub fn add_trigger_relationship(mut self, trigger_relationship: TriggerRelationship) -> Self {

2378

4

        self.inner

2379

4

            .params

2380

4

            .push(Param::TriggerRelationship(TriggerRelationshipParam {

2381

4

                trigger_relationship,

2382

4

            }));

2383

4

        self

2384

4

2385

2386

8

    pub fn finish_property(mut self) -> P {

2387

8

        self.owner

2388

8

            .add_property(ComponentProperty::Trigger(TriggerProperty {

2389

8

                value: TriggerValue::Relative(self.inner.value),

2390

8

                params: self.inner.params,

2391

8

            }));

2392

8

        self.owner

2393

8

2394

2395

2396

impl_other_component_params_builder!(RelativeTriggerPropertyBuilder<P>);

2397

2398

#[derive(Debug)]

2399

pub(crate) struct AbsoluteTriggerProperty {

2400

    pub(crate) value: CalendarDateTime,

2401

    pub(crate) params: Vec<Param>,

2402

2403

2404

pub struct AbsoluteTriggerPropertyBuilder<P: AddComponentProperty> {

2405

    owner: P,

2406

    inner: AbsoluteTriggerProperty,

2407

2408

2409

impl<P> AbsoluteTriggerPropertyBuilder<P>

2410

where

2411

    P: AddComponentProperty,

2412

2413

8

    pub(crate) fn new(

2414

8

        owner: P,

2415

8

        date: time::Date,

2416

8

        time: time::Time,

2417

8

    ) -> AbsoluteTriggerPropertyBuilder<P> {

2418

8

        AbsoluteTriggerPropertyBuilder {

2419

8

            owner,

2420

8

            inner: AbsoluteTriggerProperty {

2421

8

                value: (date, time, false).into(),

2422

8

                params: vec![Param::ValueType(ValueTypeParam {

2423

8

                    value: Value::DateTime,

2424

8

                })],

2425

8

},

2426

8

2427

8

2428

2429

    add_is_utc!();

2430

2431

8

    pub fn finish_property(mut self) -> P {

2432

8

        self.owner

2433

8

            .add_property(ComponentProperty::Trigger(TriggerProperty {

2434

8

                value: TriggerValue::Absolute(self.inner.value),

2435

8

                params: self.inner.params,

2436

8

            }));

2437

8

        self.owner

2438

8

2439

2440

2441

impl_other_component_params_builder!(AbsoluteTriggerPropertyBuilder<P>);

2442

2443

#[derive(Debug, PartialEq)]

2444

pub struct RepeatProperty {

2445

    pub(crate) value: u32,

2446

    pub(crate) params: Vec<Param>,

2447

2448

2449

impl_property_access!(RepeatProperty, u32);

2450

2451

pub struct RepeatPropertyBuilder<P: AddComponentProperty> {

2452

    owner: P,

2453

    inner: RepeatProperty,

2454

2455

2456

impl<P> RepeatPropertyBuilder<P>

2457

where

2458

    P: AddComponentProperty,

2459

2460

16

    pub(crate) fn new(owner: P, value: u32) -> RepeatPropertyBuilder<P> {

2461

16

        RepeatPropertyBuilder {

2462

16

            owner,

2463

16

            inner: RepeatProperty {

2464

16

                value,

2465

16

                params: Vec::new(),

2466

16

},

2467

16

2468

16

2469

2470

    impl_finish_component_property_build!(ComponentProperty::Repeat);

2471

2472

2473

impl_other_component_params_builder!(RepeatPropertyBuilder<P>);