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::model::impl_property_access;

21

pub use duration::*;

22

pub use recur::*;

23

24

pub trait AddComponentProperty {

25

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

26

27

28

pub trait DateTimeQuery {

29

    fn is_date(&self) -> bool;

30

    fn is_local_time(&self) -> bool;

31

    fn is_utc(&self) -> bool;

32

    fn is_local_time_with_timezone(&self) -> bool;

33

34

35

macro_rules! impl_date_time_query {

36

    ($for_type:ty) => {

37

        impl DateTimeQuery for $for_type {

38

            fn is_date(&self) -> bool {

39

                self.value.is_date()

40

41

42

            // Form 1, local date-time

43

28

            fn is_local_time(&self) -> bool {

44

28

                self.value.is_date_time()

45

28

                    && !self.value.is_utc()

46

22

                    && !self

47

22

                        .params

48

22

                        .iter()

49

26

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

50

28

51

52

            // Form 2, UTC date-time

53

26

            fn is_utc(&self) -> bool {

54

26

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

55

26

56

57

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

58

20

            fn is_local_time_with_timezone(&self) -> bool {

59

20

                self.value.is_date_time()

60

20

                    && self

61

20

                        .params

62

20

                        .iter()

63

24

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

64

20

65

66

};

67

68

69

#[derive(Debug, Eq, PartialEq)]

70

pub enum Classification {

71

    Public,

72

    Private,

73

    Confidential,

74

    XName(String),

75

    IanaToken(String),

76

77

78

impl Display for Classification {

79

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

80

        let str = match self {

81

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

82

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

83

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

84

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

85

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

86

};

87

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

88

89

90

91

pub enum StatusEvent {

92

    Tentative,

93

    Confirmed,

94

    Cancelled,

95

96

97

impl From<StatusEvent> for Status {

98

14

    fn from(status: StatusEvent) -> Self {

99

14

        match status {

100

2

            StatusEvent::Tentative => Status::Tentative,

101

12

            StatusEvent::Confirmed => Status::Confirmed,

102

            StatusEvent::Cancelled => Status::Cancelled,

103

104

14

105

106

107

pub enum StatusToDo {

108

    NeedsAction,

109

    Completed,

110

    InProcess,

111

    Cancelled,

112

113

114

impl From<StatusToDo> for Status {

115

12

    fn from(status: StatusToDo) -> Self {

116

12

        match status {

117

            StatusToDo::NeedsAction => Status::NeedsAction,

118

            StatusToDo::Completed => Status::Completed,

119

12

            StatusToDo::InProcess => Status::InProcess,

120

            StatusToDo::Cancelled => Status::Cancelled,

121

122

12

123

124

125

pub enum StatusJournal {

126

    Draft,

127

    Final,

128

    Cancelled,

129

130

131

impl From<StatusJournal> for Status {

132

12

    fn from(status: StatusJournal) -> Self {

133

12

        match status {

134

12

            StatusJournal::Draft => Status::Draft,

135

            StatusJournal::Final => Status::Final,

136

            StatusJournal::Cancelled => Status::Cancelled,

137

138

12

139

140

141

macro_rules! impl_finish_property_build {

142

    ($ev:expr) => {

143

72

        pub fn finish_property(mut self) -> ICalObjectBuilder {

144

72

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

145

72

            self.owner

146

72

147

};

148

149

150

macro_rules! impl_finish_component_property_build {

151

    ($ev:expr) => {

152

686

        pub fn finish_property(mut self) -> P {

153

686

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

154

686

            self.owner

155

686

156

};

157

158

159

#[derive(Debug, PartialEq)]

160

pub enum CalendarProperty {

161

    ProductId(ProductIdProperty),

162

    Version(VersionProperty),

163

    CalendarScale(CalendarScaleProperty),

164

    Method(MethodProperty),

165

    XProperty(XProperty),

166

    IanaProperty(IanaProperty),

167

168

169

#[derive(Debug, PartialEq)]

170

pub struct ProductIdProperty {

171

    pub(crate) value: String,

172

    pub(crate) params: Vec<Param>,

173

174

175

pub struct ProductIdPropertyBuilder {

176

    owner: ICalObjectBuilder,

177

    inner: ProductIdProperty,

178

179

180

impl ProductIdPropertyBuilder {

181

22

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

182

22

        ProductIdPropertyBuilder {

183

22

            owner,

184

22

            inner: ProductIdProperty {

185

22

                value,

186

22

                params: Vec::new(),

187

22

},

188

22

189

22

190

191

    impl_finish_property_build!(CalendarProperty::ProductId);

192

193

194

impl_other_params_builder!(ProductIdPropertyBuilder);

195

196

#[derive(Debug, PartialEq)]

197

pub struct VersionProperty {

198

    pub(crate) min_version: Option<String>,

199

    pub(crate) max_version: String,

200

    pub(crate) params: Vec<Param>,

201

202

203

pub struct VersionPropertyBuilder {

204

    owner: ICalObjectBuilder,

205

    inner: VersionProperty,

206

207

208

impl VersionPropertyBuilder {

209

18

    pub(crate) fn new(

210

18

        owner: ICalObjectBuilder,

211

18

        min_version: Option<String>,

212

18

        max_version: String,

213

18

    ) -> VersionPropertyBuilder {

214

18

        VersionPropertyBuilder {

215

18

            owner,

216

18

            inner: VersionProperty {

217

18

                min_version,

218

18

                max_version,

219

18

                params: Vec::new(),

220

18

},

221

18

222

18

223

224

    impl_finish_property_build!(CalendarProperty::Version);

225

226

227

impl_other_params_builder!(VersionPropertyBuilder);

228

229

#[derive(Debug, PartialEq)]

230

pub struct CalendarScaleProperty {

231

    pub(crate) value: String,

232

    pub(crate) params: Vec<Param>,

233

234

235

pub struct CalendarScalePropertyBuilder {

236

    owner: ICalObjectBuilder,

237

    inner: CalendarScaleProperty,

238

239

240

impl CalendarScalePropertyBuilder {

241

14

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

242

14

        CalendarScalePropertyBuilder {

243

14

            owner,

244

14

            inner: CalendarScaleProperty {

245

14

                value,

246

14

                params: Vec::new(),

247

14

},

248

14

249

14

250

251

    impl_finish_property_build!(CalendarProperty::CalendarScale);

252

253

254

impl_other_params_builder!(CalendarScalePropertyBuilder);

255

256

#[derive(Debug, PartialEq)]

257

pub struct MethodProperty {

258

    pub(crate) value: String,

259

    pub(crate) params: Vec<Param>,

260

261

262

pub struct MethodPropertyBuilder {

263

    owner: ICalObjectBuilder,

264

    inner: MethodProperty,

265

266

267

impl MethodPropertyBuilder {

268

14

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

269

14

        MethodPropertyBuilder {

270

14

            owner,

271

14

            inner: MethodProperty {

272

14

                params: Vec::new(),

273

14

                value,

274

14

},

275

14

276

14

277

278

    impl_finish_property_build!(CalendarProperty::Method);

279

280

281

impl_other_params_builder!(MethodPropertyBuilder);

282

283

#[derive(Debug, PartialEq)]

284

pub enum ComponentProperty {

285

    /// RFC 5545, 3.8.1.1

286

    /// Value type: URI or BINARY

287

    Attach(AttachProperty),

288

    /// RFC 5545, 3.8.1.2

289

    /// Value type: TEXT

290

    Categories(CategoriesProperty),

291

    /// RFC 5545, 3.8.1.3

292

    /// Value type: TEXT

293

    Classification(ClassificationProperty),

294

    /// RFC 5545, 3.8.1.4

295

    /// Value type: TEXT

296

    Comment(CommentProperty),

297

    /// RFC 5545, 3.8.1.5

298

    /// Value type: TEXT

299

    Description(DescriptionProperty),

300

    /// RFC 5545, 3.8.1.6

301

    /// Value type: FLOAT

302

    GeographicPosition(GeographicPositionProperty),

303

    /// RFC 5545, 3.8.1.7

304

    /// Value type: TEXT

305

    Location(LocationProperty),

306

    /// RFC 5545, 4.8.1.8

307

    /// Value type: INTEGER

308

    PercentComplete(PercentCompleteProperty),

309

    /// RFC 5545, 3.8.1.9

310

    /// Value type: INTEGER

311

    Priority(PriorityProperty),

312

    /// RFC 5545, 3.8.1.10

313

    /// Value type: TEXT

314

    Resources(ResourcesProperty),

315

    /// RFC 5545, 3.8.1.11

316

    /// Value type: TEXT

317

    Status(StatusProperty),

318

    /// RFC 5545, 3.8.1.12

319

    /// Value type: TEXT

320

    Summary(SummaryProperty),

321

    /// RFC 5545, 3.8.2.1

322

    /// Value type: DATE-TIME

323

    DateTimeCompleted(DateTimeCompletedProperty),

324

    /// RFC 5545, 3.8.2.2

325

    /// Value type: DATE-TIME or DATE

326

    DateTimeEnd(DateTimeEndProperty),

327

    /// RFC 5545, 3.8.2.3

328

    /// Value type: DATE-TIME or DATE

329

    DateTimeDue(DateTimeDueProperty),

330

    /// RFC 5545, 3.8.2.4

331

    /// Value type: DATE-TIME or DATE

332

    DateTimeStart(DateTimeStartProperty),

333

    /// RFC 5545, 3.8.2.5

334

    /// Value type: DURATION

335

    Duration(DurationProperty),

336

    /// RFC 5545, 3.8.2.6

337

    /// Value type: PERIOD

338

    FreeBusyTime(FreeBusyTimeProperty),

339

    /// RFC 5545, 3.8.2.7

340

    /// Value type: TEXT

341

    TimeTransparency(TimeTransparencyProperty),

342

    /// RFC 5545, 3.8.3.1

343

    /// Value type: TEXT

344

    TimeZoneId(TimeZoneIdProperty),

345

    /// RFC 5545, 3.8.3.2

346

    /// Value type: TEXT

347

    TimeZoneName(TimeZoneNameProperty),

348

    /// RFC 5545, 3.8.3.3

349

    /// Value type: UTC-OFFSET

350

    TimeZoneOffsetFrom(TimeZoneOffsetFromProperty),

351

    /// RFC 5545, 3.8.3.4

352

    /// Value type: UTC-OFFSET

353

    TimeZoneOffsetTo(TimeZoneOffsetToProperty),

354

    /// RFC 5545, 3.8.3.5

355

    /// Value type: URI

356

    TimeZoneUrl(TimeZoneUrlProperty),

357

    /// RFC 5545, 3.8.4.1

358

    /// Value type: CAL-ADDRESS

359

    Attendee(AttendeeProperty),

360

    /// RFC 5545, 3.8.4.2

361

    /// Value type: TEXT

362

    Contact(ContactProperty),

363

    /// RFC 5545, 3.8.4.3

364

    /// Value type: CAL-ADDRESS

365

    Organizer(OrganizerProperty),

366

    /// RFC 5545, 3.8.4.4

367

    /// Value type: DATE-TIME or DATE

368

    RecurrenceId(RecurrenceIdProperty),

369

    /// RFC 5545, 3.8.4.5

370

    /// Value type: TEXT

371

    RelatedTo(RelatedToProperty),

372

    /// RFC 5545, 3.8.4.6

373

    /// Value type: URI

374

    Url(UrlProperty),

375

    /// RFC 5545, 3.8.4.7

376

    /// Value type: TEXT

377

    UniqueIdentifier(UniqueIdentifierProperty),

378

    /// RFC 5545, 3.8.5.1

379

    /// Value type: DATE-TIME or DATE

380

    ExceptionDateTimes(ExceptionDateTimesProperty),

381

    /// RFC 5545, 3.8.5.2

382

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

383

    RecurrenceDateTimes(RecurrenceDateTimesProperty),

384

    /// RFC 5545, 3.8.5.3

385

    /// Value type: RECUR

386

    RecurrenceRule(RecurrenceRuleProperty),

387

    /// RFC 5545, 3.8.6.1

388

    /// Value type: TEXT

389

    Action(ActionProperty),

390

    /// RFC 5545, 3.8.6.2

391

    /// Value type: INTEGER

392

    Repeat(RepeatProperty),

393

    /// RFC 5545, 3.8.6.3

394

    /// Value type: DURATION or DATE-TIME

395

    Trigger(TriggerProperty),

396

    /// RFC 5545, 3.8.7.1

397

    /// Value type: DATE-TIME

398

    DateTimeCreated(CreatedProperty),

399

    /// RFC 5545, 3.8.7.2

400

    /// Value type: DATE-TIME

401

    DateTimeStamp(DateTimeStampProperty),

402

    /// RFC 5545, 3.8.7.3

403

    /// Value type: DATE-TIME

404

    LastModified(LastModifiedProperty),

405

    /// RFC 5545, 3.8.7.4

406

    /// Value type: INTEGER

407

    Sequence(SequenceProperty),

408

    /// RFC 5545, 3.8.8.1

409

    /// Value type: TEXT or any other type

410

    IanaProperty(IanaProperty),

411

    /// RFC 5545, 3.8.8.2

412

    /// Value type: TEXT or any other type

413

    XProperty(XProperty),

414

    /// RFC 5545, 3.8.8.3

415

    /// Value type: TEXT

416

    RequestStatus(RequestStatusProperty),

417

418

419

impl ComponentProperty {

420

2280

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

421

2280

        match self {

422

158

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

423

158

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

424

170

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

425

36

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

426

36

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

427

96

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

428

20

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

429

42

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

430

26

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

431

48

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

432

20

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

433

30

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

434

48

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

435

10

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

436

24

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

437

40

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

438

30

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

439

176

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

440

44

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

441

62

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

442

54

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

443

40

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

444

24

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

445

36

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

446

28

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

447

20

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

448

30

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

449

18

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

450

12

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

451

64

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

452

6

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

453

10

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

454

10

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

455

6

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

456

26

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

457

10

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

458

40

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

459

40

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

460

30

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

461

52

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

462

92

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

463

42

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

464

168

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

465

148

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

466

467

2280

468

469

470

pub trait ComponentPropertyInner<T> {

471

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

472

473

474

macro_rules! impl_component_property_inner {

475

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

476

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

477

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

478

479

114

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

480

114

                match self {

481

48

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

482

66

                    _ => None,

483

484

114

485

486

};

487

488

489

impl_component_property_inner!(ClassificationProperty, Classification);

490

impl_component_property_inner!(DescriptionProperty, Description);

491

impl_component_property_inner!(GeographicPositionProperty, GeographicPosition);

492

impl_component_property_inner!(LocationProperty, Location);

493

impl_component_property_inner!(PercentCompleteProperty, PercentComplete);

494

impl_component_property_inner!(PriorityProperty, Priority);

495

impl_component_property_inner!(StatusProperty, Status);

496

impl_component_property_inner!(SummaryProperty, Summary);

497

impl_component_property_inner!(DateTimeCompletedProperty, DateTimeCompleted);

498

impl_component_property_inner!(DateTimeEndProperty, DateTimeEnd);

499

impl_component_property_inner!(DateTimeDueProperty, DateTimeDue);

500

impl_component_property_inner!(DateTimeStartProperty, DateTimeStart);

501

impl_component_property_inner!(DurationProperty, Duration);

502

impl_component_property_inner!(TimeTransparencyProperty, TimeTransparency);

503

impl_component_property_inner!(TimeZoneIdProperty, TimeZoneId);

504

impl_component_property_inner!(TimeZoneOffsetFromProperty, TimeZoneOffsetFrom);

505

impl_component_property_inner!(TimeZoneOffsetToProperty, TimeZoneOffsetTo);

506

impl_component_property_inner!(TimeZoneUrlProperty, TimeZoneUrl);

507

impl_component_property_inner!(OrganizerProperty, Organizer);

508

impl_component_property_inner!(RecurrenceIdProperty, RecurrenceId);

509

impl_component_property_inner!(UrlProperty, Url);

510

impl_component_property_inner!(UniqueIdentifierProperty, UniqueIdentifier);

511

impl_component_property_inner!(RecurrenceRuleProperty, RecurrenceRule);

512

impl_component_property_inner!(ActionProperty, Action);

513

impl_component_property_inner!(RepeatProperty, Repeat);

514

impl_component_property_inner!(TriggerProperty, Trigger);

515

impl_component_property_inner!(CreatedProperty, DateTimeCreated);

516

impl_component_property_inner!(DateTimeStampProperty, DateTimeStamp);

517

impl_component_property_inner!(LastModifiedProperty, LastModified);

518

impl_component_property_inner!(SequenceProperty, Sequence);

519

impl_component_property_inner!(ContactProperty, Contact);

520

impl_component_property_inner!(AttachProperty, Attach);

521

522

pub trait ComponentPropertiesInner<T> {

523

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

524

525

526

macro_rules! impl_component_properties_inner {

527

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

528

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

529

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

530

531

312

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

532

312

                match self {

533

18

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

534

294

                    _ => None,

535

536

312

537

538

};

539

540

541

impl_component_properties_inner!(AttachProperty, Attach);

542

impl_component_properties_inner!(CategoriesProperty, Categories);

543

impl_component_properties_inner!(AttendeeProperty, Attendee);

544

impl_component_properties_inner!(RecurrenceRuleProperty, RecurrenceRule);

545

impl_component_properties_inner!(CommentProperty, Comment);

546

impl_component_properties_inner!(ContactProperty, Contact);

547

impl_component_properties_inner!(ExceptionDateTimesProperty, ExceptionDateTimes);

548

impl_component_properties_inner!(RecurrenceDateTimesProperty, RecurrenceDateTimes);

549

impl_component_properties_inner!(RequestStatusProperty, RequestStatus);

550

impl_component_properties_inner!(RelatedToProperty, RelatedTo);

551

impl_component_properties_inner!(ResourcesProperty, Resources);

552

impl_component_properties_inner!(DescriptionProperty, Description);

553

impl_component_properties_inner!(FreeBusyTimeProperty, FreeBusyTime);

554

impl_component_properties_inner!(TimeZoneNameProperty, TimeZoneName);

555

556

#[derive(Debug, PartialEq)]

557

pub struct TriggerProperty {

558

    pub(crate) value: TriggerValue,

559

    pub(crate) params: Vec<Param>,

560

561

562

#[derive(Debug, PartialEq)]

563

pub enum TriggerValue {

564

    Relative(Duration),

565

    Absolute(CalendarDateTime),

566

567

568

impl_property_access!(TriggerProperty, TriggerValue);

569

570

#[derive(Debug, PartialEq)]

571

pub struct XProperty {

572

    pub(crate) name: String,

573

    pub(crate) value: String,

574

    pub(crate) params: Vec<Param>,

575

576

577

impl_property_access!(XProperty, String);

578

579

pub struct XPropertyBuilder {

580

    owner: ICalObjectBuilder,

581

    inner: XProperty,

582

583

584

impl XPropertyBuilder {

585

2

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

586

2

        XPropertyBuilder {

587

2

            owner,

588

2

            inner: XProperty {

589

2

                name,

590

2

                value,

591

2

                params: Vec::new(),

592

2

},

593

2

594

2

595

596

    impl_finish_property_build!(CalendarProperty::XProperty);

597

598

599

impl_other_params_builder!(XPropertyBuilder);

600

601

#[derive(Debug, PartialEq)]

602

pub struct IanaProperty {

603

    pub(crate) name: String,

604

    pub(crate) value: String,

605

    pub(crate) params: Vec<Param>,

606

607

608

impl_property_access!(IanaProperty, String);

609

610

pub struct IanaPropertyBuilder {

611

    owner: ICalObjectBuilder,

612

    inner: IanaProperty,

613

614

615

impl IanaPropertyBuilder {

616

2

    pub(crate) fn new(

617

2

        owner: ICalObjectBuilder,

618

2

        name: String,

619

2

        value: String,

620

2

    ) -> IanaPropertyBuilder {

621

2

        IanaPropertyBuilder {

622

2

            owner,

623

2

            inner: IanaProperty {

624

2

                name,

625

2

                value,

626

2

                params: Vec::new(),

627

2

},

628

2

629

2

630

631

    impl_finish_property_build!(CalendarProperty::IanaProperty);

632

633

634

impl_other_params_builder!(IanaPropertyBuilder);

635

636

pub struct XComponentPropertyBuilder<P> {

637

    owner: P,

638

    inner: XProperty,

639

640

641

impl<P> XComponentPropertyBuilder<P>

642

where

643

    P: AddComponentProperty,

644

645

56

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

646

56

        XComponentPropertyBuilder {

647

56

            owner,

648

56

            inner: XProperty {

649

56

                params: Vec::new(),

650

56

                name,

651

56

                value,

652

56

},

653

56

654

56

655

656

    impl_finish_component_property_build!(ComponentProperty::XProperty);

657

658

659

impl_other_component_params_builder!(XComponentPropertyBuilder<P>);

660

661

pub struct IanaComponentPropertyBuilder<P> {

662

    owner: P,

663

    inner: IanaProperty,

664

665

666

impl<P> IanaComponentPropertyBuilder<P>

667

where

668

    P: AddComponentProperty,

669

670

56

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

671

56

        IanaComponentPropertyBuilder {

672

56

            owner,

673

56

            inner: IanaProperty {

674

56

                name,

675

56

                value,

676

56

                params: Vec::new(),

677

56

},

678

56

679

56

680

681

    impl_finish_component_property_build!(ComponentProperty::IanaProperty);

682

683

684

impl_other_component_params_builder!(IanaComponentPropertyBuilder<P>);

685

686

#[derive(Debug, PartialEq)]

687

pub struct DateTimeStampProperty {

688

    pub(crate) value: CalendarDateTime,

689

    pub(crate) params: Vec<Param>,

690

691

692

impl_property_access!(DateTimeStampProperty, CalendarDateTime);

693

694

pub struct DateTimeStampPropertyBuilder<P: AddComponentProperty> {

695

    owner: P,

696

    inner: DateTimeStampProperty,

697

698

699

impl<P> DateTimeStampPropertyBuilder<P>

700

where

701

    P: AddComponentProperty,

702

703

50

    pub(crate) fn new(

704

50

        owner: P,

705

50

        date: time::Date,

706

50

        time: time::Time,

707

50

    ) -> DateTimeStampPropertyBuilder<P> {

708

50

        DateTimeStampPropertyBuilder {

709

50

            owner,

710

50

            inner: DateTimeStampProperty {

711

50

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

712

50

                params: Vec::new(),

713

50

},

714

50

715

50

716

717

    add_is_utc!();

718

719

    impl_finish_component_property_build!(ComponentProperty::DateTimeStamp);

720

721

722

impl_other_component_params_builder!(DateTimeStampPropertyBuilder<P>);

723

724

#[derive(Debug, PartialEq)]

725

pub struct UniqueIdentifierProperty {

726

    pub(crate) value: String,

727

    pub(crate) params: Vec<Param>,

728

729

730

impl_property_access!(UniqueIdentifierProperty, String);

731

732

pub struct UniqueIdentifierPropertyBuilder<P: AddComponentProperty> {

733

    owner: P,

734

    inner: UniqueIdentifierProperty,

735

736

737

impl<P> UniqueIdentifierPropertyBuilder<P>

738

where

739

    P: AddComponentProperty,

740

741

18

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

742

18

        UniqueIdentifierPropertyBuilder {

743

18

            owner,

744

18

            inner: UniqueIdentifierProperty {

745

18

                value,

746

18

                params: Vec::new(),

747

18

},

748

18

749

18

750

751

    impl_finish_component_property_build!(ComponentProperty::UniqueIdentifier);

752

753

754

impl_other_component_params_builder!(UniqueIdentifierPropertyBuilder<P>);

755

756

#[derive(Debug, Clone, PartialEq)]

757

pub struct DateTimeStartProperty {

758

    pub(crate) value: CalendarDateTime,

759

    pub(crate) params: Vec<Param>,

760

761

762

impl_property_access!(DateTimeStartProperty, CalendarDateTime);

763

764

pub struct DateTimeStartPropertyBuilder<P: AddComponentProperty> {

765

    owner: P,

766

    inner: DateTimeStartProperty,

767

768

769

impl<P> DateTimeStartPropertyBuilder<P>

770

where

771

    P: AddComponentProperty,

772

773

74

    pub(crate) fn new(

774

74

        owner: P,

775

74

        date: time::Date,

776

74

        time: Option<time::Time>,

777

74

    ) -> DateTimeStartPropertyBuilder<P> {

778

74

        let mut params = Vec::new();

779

74

780

74

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

781

74

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

782

74

        if time.is_none() {

783

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

784

74

785

786

74

        DateTimeStartPropertyBuilder {

787

74

            owner,

788

74

            inner: DateTimeStartProperty {

789

74

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

790

74

                params,

791

74

},

792

74

793

74

794

795

    tz_id_param!();

796

797

    add_is_utc!();

798

799

    impl_finish_component_property_build!(ComponentProperty::DateTimeStart);

800

801

802

impl_other_component_params_builder!(DateTimeStartPropertyBuilder<P>);

803

804

impl_date_time_query!(DateTimeStartProperty);

805

806

#[derive(Debug, PartialEq)]

807

pub struct ClassificationProperty {

808

    pub(crate) value: Classification,

809

    pub(crate) params: Vec<Param>,

810

811

812

impl_property_access!(ClassificationProperty, Classification);

813

814

pub struct ClassificationPropertyBuilder<P: AddComponentProperty> {

815

    owner: P,

816

    inner: ClassificationProperty,

817

818

819

impl<P> ClassificationPropertyBuilder<P>

820

where

821

    P: AddComponentProperty,

822

823

38

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

824

38

        ClassificationPropertyBuilder {

825

38

            owner,

826

38

            inner: ClassificationProperty {

827

38

                value,

828

38

                params: Vec::new(),

829

38

},

830

38

831

38

832

833

    impl_finish_component_property_build!(ComponentProperty::Classification);

834

835

836

impl_other_component_params_builder!(ClassificationPropertyBuilder<P>);

837

838

#[derive(Debug, PartialEq)]

839

pub struct CreatedProperty {

840

    pub(crate) value: CalendarDateTime,

841

    pub(crate) params: Vec<Param>,

842

843

844

impl_property_access!(CreatedProperty, CalendarDateTime);

845

846

pub struct CreatedPropertyBuilder<P: AddComponentProperty> {

847

    owner: P,

848

    inner: CreatedProperty,

849

850

851

impl<P> CreatedPropertyBuilder<P>

852

where

853

    P: AddComponentProperty,

854

855

38

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

856

38

        CreatedPropertyBuilder {

857

38

            owner,

858

38

            inner: CreatedProperty {

859

38

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

860

38

                params: Vec::new(),

861

38

},

862

38

863

38

864

865

    add_is_utc!();

866

867

    impl_finish_component_property_build!(ComponentProperty::DateTimeCreated);

868

869

870

impl_other_component_params_builder!(CreatedPropertyBuilder<P>);

871

872

#[derive(Debug, PartialEq)]

873

pub struct DescriptionProperty {

874

    pub(crate) value: String,

875

    pub(crate) params: Vec<Param>,

876

877

878

impl_property_access!(DescriptionProperty, String);

879

880

pub struct DescriptionPropertyBuilder<P: AddComponentProperty> {

881

    owner: P,

882

    inner: DescriptionProperty,

883

884

885

impl<P> DescriptionPropertyBuilder<P>

886

where

887

    P: AddComponentProperty,

888

889

26

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

890

26

        DescriptionPropertyBuilder {

891

26

            owner,

892

26

            inner: DescriptionProperty {

893

26

                value,

894

26

                params: Vec::new(),

895

26

},

896

26

897

26

898

899

    altrep_param!();

900

    language_param!();

901

902

    impl_finish_component_property_build!(ComponentProperty::Description);

903

904

905

impl_other_component_params_builder!(DescriptionPropertyBuilder<P>);

906

907

#[derive(Debug, PartialEq)]

908

pub struct GeographicPositionProperty {

909

    pub(crate) value: GeographicPositionPropertyValue,

910

    pub(crate) params: Vec<Param>,

911

912

913

#[derive(Debug, PartialEq)]

914

pub struct GeographicPositionPropertyValue {

915

    pub latitude: f64,

916

    pub longitude: f64,

917

918

919

impl_property_access!(GeographicPositionProperty, GeographicPositionPropertyValue);

920

921

pub struct GeographicPositionPropertyBuilder<P: AddComponentProperty> {

922

    owner: P,

923

    inner: GeographicPositionProperty,

924

925

926

impl<P> GeographicPositionPropertyBuilder<P>

927

where

928

    P: AddComponentProperty,

929

930

26

    pub(crate) fn new(

931

26

        owner: P,

932

26

        latitude: f64,

933

26

        longitude: f64,

934

26

    ) -> GeographicPositionPropertyBuilder<P> {

935

26

        GeographicPositionPropertyBuilder {

936

26

            owner,

937

26

            inner: GeographicPositionProperty {

938

26

                value: GeographicPositionPropertyValue {

939

26

                    latitude,

940

26

                    longitude,

941

26

},

942

26

                params: Vec::new(),

943

26

},

944

26

945

26

946

947

    impl_finish_component_property_build!(ComponentProperty::GeographicPosition);

948

949

950

impl_other_component_params_builder!(GeographicPositionPropertyBuilder<P>);

951

952

#[derive(Debug, PartialEq)]

953

pub struct LastModifiedProperty {

954

    pub(crate) value: CalendarDateTime,

955

    pub(crate) params: Vec<Param>,

956

957

958

impl_property_access!(LastModifiedProperty, CalendarDateTime);

959

960

pub struct LastModifiedPropertyBuilder<P: AddComponentProperty> {

961

    owner: P,

962

    inner: LastModifiedProperty,

963

964

965

impl<P> LastModifiedPropertyBuilder<P>

966

where

967

    P: AddComponentProperty,

968

969

50

    pub(crate) fn new(

970

50

        owner: P,

971

50

        date: time::Date,

972

50

        time: time::Time,

973

50

    ) -> LastModifiedPropertyBuilder<P> {

974

50

        LastModifiedPropertyBuilder {

975

50

            owner,

976

50

            inner: LastModifiedProperty {

977

50

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

978

50

                params: Vec::new(),

979

50

},

980

50

981

50

982

983

    add_is_utc!();

984

985

    impl_finish_component_property_build!(ComponentProperty::LastModified);

986

987

988

impl_other_component_params_builder!(LastModifiedPropertyBuilder<P>);

989

990

#[derive(Debug, PartialEq)]

991

pub struct LocationProperty {

992

    pub(crate) value: String,

993

    pub(crate) params: Vec<Param>,

994

995

996

impl_property_access!(LocationProperty, String);

997

998

pub struct LocationPropertyBuilder<P: AddComponentProperty> {

999

    owner: P,

1000

    inner: LocationProperty,

1001

1002

1003

impl<P> LocationPropertyBuilder<P>

1004

where

1005

    P: AddComponentProperty,

1006

1007

24

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

1008

24

        LocationPropertyBuilder {

1009

24

            owner,

1010

24

            inner: LocationProperty {

1011

24

                value,

1012

24

                params: Vec::new(),

1013

24

},

1014

24

1015

24

1016

1017

    altrep_param!();

1018

    language_param!();

1019

1020

    impl_finish_component_property_build!(ComponentProperty::Location);

1021

1022

1023

impl_other_component_params_builder!(LocationPropertyBuilder<P>);

1024

1025

#[derive(Debug, PartialEq)]

1026

pub struct OrganizerProperty {

1027

    pub(crate) value: String,

1028

    pub(crate) params: Vec<Param>,

1029

1030

1031

impl_property_access!(OrganizerProperty, String);

1032

1033

pub struct OrganizerPropertyBuilder<P: AddComponentProperty> {

1034

    owner: P,

1035

    inner: OrganizerProperty,

1036

1037

1038

impl<P> OrganizerPropertyBuilder<P>

1039

where

1040

    P: AddComponentProperty,

1041

1042

50

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

1043

50

        OrganizerPropertyBuilder {

1044

50

            owner,

1045

50

            inner: OrganizerProperty {

1046

50

                value,

1047

50

                params: Vec::new(),

1048

50

},

1049

50

1050

50

1051

1052

    common_name_param!();

1053

1054

    directory_entry_reference_param!();

1055

1056

    sent_by_param!();

1057

1058

    language_param!();

1059

1060

    impl_finish_component_property_build!(ComponentProperty::Organizer);

1061

1062

1063

impl_other_component_params_builder!(OrganizerPropertyBuilder<P>);

1064

1065

#[derive(Debug, PartialEq)]

1066

pub struct PriorityProperty {

1067

    pub(crate) value: u8,

1068

    pub(crate) params: Vec<Param>,

1069

1070

1071

impl_property_access!(PriorityProperty, u8);

1072

1073

pub struct PriorityPropertyBuilder<P: AddComponentProperty> {

1074

    owner: P,

1075

    inner: PriorityProperty,

1076

1077

1078

impl<P> PriorityPropertyBuilder<P>

1079

where

1080

    P: AddComponentProperty,

1081

1082

26

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

1083

26

        PriorityPropertyBuilder {

1084

26

            owner,

1085

26

            inner: PriorityProperty {

1086

26

                value,

1087

26

                params: Vec::new(),

1088

26

},

1089

26

1090

26

1091

1092

    impl_finish_component_property_build!(ComponentProperty::Priority);

1093

1094

1095

impl_other_component_params_builder!(PriorityPropertyBuilder<P>);

1096

1097

#[derive(Debug, PartialEq)]

1098

pub struct SequenceProperty {

1099

    pub(crate) value: u32,

1100

    pub(crate) params: Vec<Param>,

1101

1102

1103

impl_property_access!(SequenceProperty, u32);

1104

1105

pub struct SequencePropertyBuilder<P: AddComponentProperty> {

1106

    owner: P,

1107

    inner: SequenceProperty,

1108

1109

1110

impl<P> SequencePropertyBuilder<P>

1111

where

1112

    P: AddComponentProperty,

1113

1114

38

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

1115

38

        SequencePropertyBuilder {

1116

38

            owner,

1117

38

            inner: SequenceProperty {

1118

38

                value,

1119

38

                params: Vec::new(),

1120

38

},

1121

38

1122

38

1123

1124

    impl_finish_component_property_build!(ComponentProperty::Sequence);

1125

1126

1127

impl_other_component_params_builder!(SequencePropertyBuilder<P>);

1128

1129

#[derive(Debug, PartialEq)]

1130

pub struct RequestStatusProperty {

1131

    pub(crate) value: RequestStatusPropertyValue,

1132

    pub(crate) params: Vec<Param>,

1133

1134

1135

#[derive(Debug, PartialEq)]

1136

pub struct RequestStatusPropertyValue {

1137

    pub(crate) status_code: Vec<u32>,

1138

    pub(crate) description: String,

1139

    pub(crate) exception_data: Option<String>,

1140

1141

1142

impl_property_access!(RequestStatusProperty, RequestStatusPropertyValue);

1143

1144

pub struct RequestStatusPropertyBuilder<P: AddComponentProperty> {

1145

    owner: P,

1146

    inner: RequestStatusProperty,

1147

1148

1149

impl<P> RequestStatusPropertyBuilder<P>

1150

where

1151

    P: AddComponentProperty,

1152

1153

50

    pub(crate) fn new(

1154

50

        owner: P,

1155

50

        status_code: Vec<u32>,

1156

50

        description: String,

1157

50

        exception_data: Option<String>,

1158

50

    ) -> RequestStatusPropertyBuilder<P> {

1159

50

        RequestStatusPropertyBuilder {

1160

50

            owner,

1161

50

            inner: RequestStatusProperty {

1162

50

                value: RequestStatusPropertyValue {

1163

50

                    status_code,

1164

50

                    description,

1165

50

                    exception_data,

1166

50

},

1167

50

                params: Vec::new(),

1168

50

},

1169

50

1170

50

1171

1172

    language_param!();

1173

1174

    impl_finish_component_property_build!(ComponentProperty::RequestStatus);

1175

1176

1177

impl_other_component_params_builder!(RequestStatusPropertyBuilder<P>);

1178

1179

#[derive(Debug, PartialEq)]

1180

pub struct SummaryProperty {

1181

    pub(crate) value: String,

1182

    pub(crate) params: Vec<Param>,

1183

1184

1185

impl_property_access!(SummaryProperty, String);

1186

1187

pub struct SummaryPropertyBuilder<P: AddComponentProperty> {

1188

    owner: P,

1189

    inner: SummaryProperty,

1190

1191

1192

impl<P> SummaryPropertyBuilder<P>

1193

where

1194

    P: AddComponentProperty,

1195

1196

18

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

1197

18

        SummaryPropertyBuilder {

1198

18

            owner,

1199

18

            inner: SummaryProperty {

1200

18

                value,

1201

18

                params: Vec::new(),

1202

18

},

1203

18

1204

18

1205

1206

    altrep_param!();

1207

    language_param!();

1208

1209

    impl_finish_component_property_build!(ComponentProperty::Summary);

1210

1211

1212

impl_other_component_params_builder!(SummaryPropertyBuilder<P>);

1213

1214

#[derive(Debug, PartialEq)]

1215

pub struct TimeTransparencyProperty {

1216

    pub(crate) value: TimeTransparency,

1217

    pub(crate) params: Vec<Param>,

1218

1219

1220

impl_property_access!(TimeTransparencyProperty, TimeTransparency);

1221

1222

pub struct TimeTransparencyPropertyBuilder<P: AddComponentProperty> {

1223

    owner: P,

1224

    inner: TimeTransparencyProperty,

1225

1226

1227

impl<P> TimeTransparencyPropertyBuilder<P>

1228

where

1229

    P: AddComponentProperty,

1230

1231

14

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

1232

14

        TimeTransparencyPropertyBuilder {

1233

14

            owner,

1234

14

            inner: TimeTransparencyProperty {

1235

14

                value,

1236

14

                params: Vec::new(),

1237

14

},

1238

14

1239

14

1240

1241

    impl_finish_component_property_build!(ComponentProperty::TimeTransparency);

1242

1243

1244

impl_other_component_params_builder!(TimeTransparencyPropertyBuilder<P>);

1245

1246

#[derive(Debug, PartialEq)]

1247

pub struct UrlProperty {

1248

    // TODO should be a URI

1249

    pub(crate) value: String,

1250

    pub(crate) params: Vec<Param>,

1251

1252

1253

impl_property_access!(UrlProperty, String);

1254

1255

pub struct UrlPropertyBuilder<P: AddComponentProperty> {

1256

    owner: P,

1257

    inner: UrlProperty,

1258

1259

1260

impl<P> UrlPropertyBuilder<P>

1261

where

1262

    P: AddComponentProperty,

1263

1264

50

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

1265

50

        UrlPropertyBuilder {

1266

50

            owner,

1267

50

            inner: UrlProperty {

1268

50

                value,

1269

50

                params: Vec::new(),

1270

50

},

1271

50

1272

50

1273

1274

    impl_finish_component_property_build!(ComponentProperty::Url);

1275

1276

1277

impl_other_component_params_builder!(UrlPropertyBuilder<P>);

1278

1279

#[derive(Debug, PartialEq)]

1280

pub struct RecurrenceIdProperty {

1281

    pub(crate) value: CalendarDateTime,

1282

    pub(crate) params: Vec<Param>,

1283

1284

1285

impl_property_access!(RecurrenceIdProperty, CalendarDateTime);

1286

1287

pub struct RecurrenceIdPropertyBuilder<P: AddComponentProperty> {

1288

    owner: P,

1289

    inner: RecurrenceIdProperty,

1290

1291

1292

impl<P> RecurrenceIdPropertyBuilder<P>

1293

where

1294

    P: AddComponentProperty,

1295

1296

38

    pub(crate) fn new(

1297

38

        owner: P,

1298

38

        date: time::Date,

1299

38

        time: Option<time::Time>,

1300

38

    ) -> RecurrenceIdPropertyBuilder<P> {

1301

38

        let mut params = Vec::new();

1302

38

1303

38

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

1304

38

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

1305

38

        if time.is_none() {

1306

2

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

1307

36

1308

1309

38

        RecurrenceIdPropertyBuilder {

1310

38

            owner,

1311

38

            inner: RecurrenceIdProperty {

1312

38

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

1313

38

                params,

1314

38

},

1315

38

1316

38

1317

1318

    tz_id_param!();

1319

1320

    add_is_utc!();

1321

1322

14

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

1323

14

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

1324

14

        self

1325

14

1326

1327

    impl_finish_component_property_build!(ComponentProperty::RecurrenceId);

1328

1329

1330

impl_other_component_params_builder!(RecurrenceIdPropertyBuilder<P>);

1331

1332

#[derive(Debug, PartialEq)]

1333

pub struct RecurrenceRuleProperty {

1334

    pub(crate) value: RecurrenceRule,

1335

    pub(crate) params: Vec<Param>,

1336

1337

1338

impl_property_access!(RecurrenceRuleProperty, RecurrenceRule);

1339

1340

pub struct RecurrenceRulePropertyBuilder<P: AddComponentProperty> {

1341

    owner: P,

1342

    inner: RecurrenceRuleProperty,

1343

1344

1345

impl<P> RecurrenceRulePropertyBuilder<P>

1346

where

1347

    P: AddComponentProperty,

1348

1349

62

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

1350

62

        RecurrenceRulePropertyBuilder {

1351

62

            owner,

1352

62

            inner: RecurrenceRuleProperty {

1353

62

                value: rule,

1354

62

                params: Vec::new(),

1355

62

},

1356

62

1357

62

1358

1359

    impl_finish_component_property_build!(ComponentProperty::RecurrenceRule);

1360

1361

1362

impl_other_component_params_builder!(RecurrenceRulePropertyBuilder<P>);

1363

1364

#[derive(Debug, Clone, PartialEq)]

1365

pub struct DateTimeEndProperty {

1366

    pub(crate) value: CalendarDateTime,

1367

    pub(crate) params: Vec<Param>,

1368

1369

1370

impl_property_access!(DateTimeEndProperty, CalendarDateTime);

1371

1372

pub struct DateTimeEndPropertyBuilder<P: AddComponentProperty> {

1373

    owner: P,

1374

    inner: DateTimeEndProperty,

1375

1376

1377

impl<P> DateTimeEndPropertyBuilder<P>

1378

where

1379

    P: AddComponentProperty,

1380

1381

26

    pub(crate) fn new(

1382

26

        owner: P,

1383

26

        date: time::Date,

1384

26

        time: Option<time::Time>,

1385

26

    ) -> DateTimeEndPropertyBuilder<P> {

1386

26

        let mut params = Vec::new();

1387

26

1388

26

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

1389

26

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

1390

26

        if time.is_none() {

1391

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

1392

26

1393

1394

26

        DateTimeEndPropertyBuilder {

1395

26

            owner,

1396

26

            inner: DateTimeEndProperty {

1397

26

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

1398

26

                params,

1399

26

},

1400

26

1401

26

1402

1403

    add_is_utc!();

1404

1405

    tz_id_param!();

1406

1407

    impl_finish_component_property_build!(ComponentProperty::DateTimeEnd);

1408

1409

1410

impl_other_component_params_builder!(DateTimeEndPropertyBuilder<P>);

1411

1412

#[derive(Debug, PartialEq)]

1413

pub struct DurationProperty {

1414

    pub(crate) value: Duration,

1415

    pub(crate) params: Vec<Param>,

1416

1417

1418

impl_property_access!(DurationProperty, Duration);

1419

1420

pub struct DurationPropertyBuilder<P: AddComponentProperty> {

1421

    owner: P,

1422

    inner: DurationProperty,

1423

1424

1425

impl<P> DurationPropertyBuilder<P>

1426

where

1427

    P: AddComponentProperty,

1428

1429

30

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

1430

30

        DurationPropertyBuilder {

1431

30

            owner,

1432

30

            inner: DurationProperty {

1433

30

                value: duration,

1434

30

                params: Vec::new(),

1435

30

},

1436

30

1437

30

1438

1439

    impl_finish_component_property_build!(ComponentProperty::Duration);

1440

1441

1442

impl_other_component_params_builder!(DurationPropertyBuilder<P>);

1443

1444

#[derive(Debug, PartialEq)]

1445

pub struct AttachProperty {

1446

    pub(crate) value: String,

1447

    pub(crate) params: Vec<Param>,

1448

1449

1450

impl_property_access!(AttachProperty, String);

1451

1452

pub struct AttachPropertyBuilder<P: AddComponentProperty> {

1453

    owner: P,

1454

    inner: AttachProperty,

1455

1456

1457

impl<P> AttachPropertyBuilder<P>

1458

where

1459

    P: AddComponentProperty,

1460

1461

42

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

1462

42

        AttachPropertyBuilder {

1463

42

            owner,

1464

42

            inner: AttachProperty {

1465

42

                value: uri,

1466

42

                params: Vec::new(),

1467

42

},

1468

42

1469

42

1470

1471

4

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

1472

4

        AttachPropertyBuilder {

1473

4

            owner,

1474

4

            inner: AttachProperty {

1475

4

                value: binary,

1476

4

                params: vec![

1477

4

                    Param::Encoding(EncodingParam {

1478

4

                        encoding: Encoding::Base64,

1479

4

}),

1480

4

                    Param::ValueType(ValueTypeParam {

1481

4

                        value: Value::Binary,

1482

4

}),

1483

4

],

1484

4

},

1485

4

1486

4

1487

1488

14

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

1489

14

        mut self,

1490

14

        type_name: U,

1491

14

        sub_type_name: V,

1492

14

    ) -> Self {

1493

14

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

1494

14

            type_name: type_name.to_string(),

1495

14

            sub_type_name: sub_type_name.to_string(),

1496

14

        }));

1497

14

        self

1498

14

1499

1500

    impl_finish_component_property_build!(ComponentProperty::Attach);

1501

1502

1503

impl_other_component_params_builder!(AttachPropertyBuilder<P>);

1504

1505

#[derive(Debug, PartialEq)]

1506

pub struct AttendeeProperty {

1507

    pub(crate) value: String,

1508

    pub(crate) params: Vec<Param>,

1509

1510

1511

impl_property_access!(AttendeeProperty, String);

1512

1513

pub struct AttendeePropertyBuilder<P: AddComponentProperty, PS> {

1514

    owner: P,

1515

    inner: AttendeeProperty,

1516

    _phantom: PhantomData<PS>,

1517

1518

1519

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

1520

where

1521

    P: AddComponentProperty,

1522

    PS: Into<ParticipationStatusUnknown>,

1523

1524

54

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

1525

54

        AttendeePropertyBuilder {

1526

54

            owner,

1527

54

            inner: AttendeeProperty {

1528

54

                value,

1529

54

                params: Vec::new(),

1530

54

},

1531

54

            _phantom: PhantomData,

1532

54

1533

54

1534

1535

12

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

1536

12

        self.inner

1537

12

            .params

1538

12

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

1539

12

        self

1540

12

1541

1542

14

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

1543

14

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

1544

14

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

1545

14

        }));

1546

14

        self

1547

14

1548

1549

12

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

1550

12

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

1551

12

        self

1552

12

1553

1554

14

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

1555

14

        self.inner

1556

14

            .params

1557

14

            .push(Param::ParticipationStatus(ParticipationStatusParam {

1558

14

                status: status.into(),

1559

14

            }));

1560

14

        self

1561

14

1562

1563

12

    pub fn add_rsvp(mut self) -> Self {

1564

12

        // Default is false, add to set true

1565

12

        self.inner

1566

12

            .params

1567

12

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

1568

12

        self

1569

12

1570

1571

12

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

1572

12

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

1573

12

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

1574

12

        }));

1575

12

        self

1576

12

1577

1578

12

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

1579

12

        self.inner

1580

12

            .params

1581

12

            .push(Param::DelegatedFrom(DelegatedFromParam {

1582

12

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

1583

12

            }));

1584

12

        self

1585

12

1586

1587

    sent_by_param!();

1588

    common_name_param!();

1589

    directory_entry_reference_param!();

1590

    language_param!();

1591

1592

    impl_finish_component_property_build!(ComponentProperty::Attendee);

1593

1594

1595

impl_other_component_params_builder!(AttendeePropertyBuilder<P, PS>);

1596

1597

#[derive(Debug, PartialEq)]

1598

pub struct CategoriesProperty {

1599

    pub(crate) value: Vec<String>,

1600

    pub(crate) params: Vec<Param>,

1601

1602

1603

impl_property_access!(CategoriesProperty, Vec<String>);

1604

1605

pub struct CategoriesPropertyBuilder<P: AddComponentProperty> {

1606

    owner: P,

1607

    inner: CategoriesProperty,

1608

1609

1610

impl<P> CategoriesPropertyBuilder<P>

1611

where

1612

    P: AddComponentProperty,

1613

1614

38

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

1615

38

        CategoriesPropertyBuilder {

1616

38

            owner,

1617

38

            inner: CategoriesProperty {

1618

38

                value,

1619

38

                params: Vec::new(),

1620

38

},

1621

38

1622

38

1623

1624

    language_param!();

1625

1626

    impl_finish_component_property_build!(ComponentProperty::Categories);

1627

1628

1629

impl_other_component_params_builder!(CategoriesPropertyBuilder<P>);

1630

1631

#[derive(Debug, PartialEq)]

1632

pub struct CommentProperty {

1633

    pub(crate) value: String,

1634

    pub(crate) params: Vec<Param>,

1635

1636

1637

impl_property_access!(CommentProperty, String);

1638

1639

pub struct CommentPropertyBuilder<P: AddComponentProperty> {

1640

    owner: P,

1641

    inner: CommentProperty,

1642

1643

1644

impl<P> CommentPropertyBuilder<P>

1645

where

1646

    P: AddComponentProperty,

1647

1648

26

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

1649

26

        CommentPropertyBuilder {

1650

26

            owner,

1651

26

            inner: CommentProperty {

1652

26

                value,

1653

26

                params: Vec::new(),

1654

26

},

1655

26

1656

26

1657

1658

    altrep_param!();

1659

    language_param!();

1660

1661

    impl_finish_component_property_build!(ComponentProperty::Comment);

1662

1663

1664

impl_other_component_params_builder!(CommentPropertyBuilder<P>);

1665

1666

#[derive(Debug, PartialEq)]

1667

pub struct ContactProperty {

1668

    pub(crate) value: String,

1669

    pub(crate) params: Vec<Param>,

1670

1671

1672

impl_property_access!(ContactProperty, String);

1673

1674

pub struct ContactPropertyBuilder<P: AddComponentProperty> {

1675

    owner: P,

1676

    inner: ContactProperty,

1677

1678

1679

impl<P> ContactPropertyBuilder<P>

1680

where

1681

    P: AddComponentProperty,

1682

1683

18

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

1684

18

        ContactPropertyBuilder {

1685

18

            owner,

1686

18

            inner: ContactProperty {

1687

18

                value,

1688

18

                params: Vec::new(),

1689

18

},

1690

18

1691

18

1692

1693

    altrep_param!();

1694

    language_param!();

1695

1696

    impl_finish_component_property_build!(ComponentProperty::Contact);

1697

1698

1699

impl_other_component_params_builder!(ContactPropertyBuilder<P>);

1700

1701

#[derive(Debug, PartialEq)]

1702

pub struct ExceptionDateTimesProperty {

1703

    pub(crate) value: Vec<CalendarDateTime>,

1704

    pub(crate) params: Vec<Param>,

1705

1706

1707

impl_property_access!(ExceptionDateTimesProperty, Vec<CalendarDateTime>);

1708

1709

pub struct ExceptionDateTimesPropertyBuilder<P: AddComponentProperty> {

1710

    owner: P,

1711

    inner: ExceptionDateTimesProperty,

1712

1713

1714

impl<P> ExceptionDateTimesPropertyBuilder<P>

1715

where

1716

    P: AddComponentProperty,

1717

1718

38

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

1719

38

        let mut params = Vec::new();

1720

38

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

1721

2

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

1722

38

1723

1724

38

        ExceptionDateTimesPropertyBuilder {

1725

38

            owner,

1726

38

            inner: ExceptionDateTimesProperty {

1727

38

                value: date_times,

1728

38

                params,

1729

38

},

1730

38

1731

38

1732

1733

    tz_id_param!();

1734

1735

    impl_finish_component_property_build!(ComponentProperty::ExceptionDateTimes);

1736

1737

1738

impl_other_component_params_builder!(ExceptionDateTimesPropertyBuilder<P>);

1739

1740

#[derive(Debug, PartialEq)]

1741

pub struct StatusProperty {

1742

    pub(crate) value: Status,

1743

    pub(crate) params: Vec<Param>,

1744

1745

1746

impl_property_access!(StatusProperty, Status);

1747

1748

pub struct StatusPropertyBuilder<P: AddComponentProperty> {

1749

    owner: P,

1750

    inner: StatusProperty,

1751

1752

1753

impl<P> StatusPropertyBuilder<P>

1754

where

1755

    P: AddComponentProperty,

1756

1757

38

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

1758

38

        StatusPropertyBuilder {

1759

38

            owner,

1760

38

            inner: StatusProperty {

1761

38

                value,

1762

38

                params: Vec::new(),

1763

38

},

1764

38

1765

38

1766

1767

    impl_finish_component_property_build!(ComponentProperty::Status);

1768

1769

1770

impl_other_component_params_builder!(StatusPropertyBuilder<P>);

1771

1772

#[derive(Debug, PartialEq)]

1773

pub struct RelatedToProperty {

1774

    pub(crate) value: String,

1775

    pub(crate) params: Vec<Param>,

1776

1777

1778

impl_property_access!(RelatedToProperty, String);

1779

1780

pub struct RelatedToPropertyBuilder<P: AddComponentProperty> {

1781

    owner: P,

1782

    inner: RelatedToProperty,

1783

1784

1785

impl<P> RelatedToPropertyBuilder<P>

1786

where

1787

    P: AddComponentProperty,

1788

1789

38

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

1790

38

        RelatedToPropertyBuilder {

1791

38

            owner,

1792

38

            inner: RelatedToProperty {

1793

38

                value,

1794

38

                params: Vec::new(),

1795

38

},

1796

38

1797

38

1798

1799

14

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

1800

14

        self.inner

1801

14

            .params

1802

14

            .push(Param::RelationshipType(RelationshipTypeParam {

1803

14

                relationship: relationship_type,

1804

14

            }));

1805

14

        self

1806

14

1807

1808

    impl_finish_component_property_build!(ComponentProperty::RelatedTo);

1809

1810

1811

impl_other_component_params_builder!(RelatedToPropertyBuilder<P>);

1812

1813

#[derive(Debug, PartialEq)]

1814

pub struct ResourcesProperty {

1815

    pub(crate) value: Vec<String>,

1816

    pub(crate) params: Vec<Param>,

1817

1818

1819

impl_property_access!(ResourcesProperty, Vec<String>);

1820

1821

pub struct ResourcesPropertyBuilder<P: AddComponentProperty> {

1822

    owner: P,

1823

    inner: ResourcesProperty,

1824

1825

1826

impl<P> ResourcesPropertyBuilder<P>

1827

where

1828

    P: AddComponentProperty,

1829

1830

26

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

1831

26

        ResourcesPropertyBuilder {

1832

26

            owner,

1833

26

            inner: ResourcesProperty {

1834

26

                value,

1835

26

                params: Vec::new(),

1836

26

},

1837

26

1838

26

1839

1840

    altrep_param!();

1841

    language_param!();

1842

1843

    impl_finish_component_property_build!(ComponentProperty::Resources);

1844

1845

1846

impl_other_component_params_builder!(ResourcesPropertyBuilder<P>);

1847

1848

#[derive(Clone, Debug, PartialEq)]

1849

pub struct Period {

1850

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

1851

    pub end: PeriodEnd,

1852

1853

1854

impl Period {

1855

12

    pub fn new_explicit(

1856

12

        start_date: time::Date,

1857

12

        start_time: time::Time,

1858

12

        end_date: time::Date,

1859

12

        end_time: time::Time,

1860

12

        is_utc: bool,

1861

12

    ) -> Self {

1862

12

        Period {

1863

12

            start: (start_date, start_time, is_utc),

1864

12

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

1865

12

1866

12

1867

1868

14

    pub fn new_start(

1869

14

        start_date: time::Date,

1870

14

        start_time: time::Time,

1871

14

        is_utc: bool,

1872

14

        duration: Duration,

1873

14

    ) -> Self {

1874

14

        Period {

1875

14

            start: (start_date, start_time, is_utc),

1876

14

            end: PeriodEnd::Duration(duration),

1877

14

1878

14

1879

1880

12

    pub fn expand(&self) -> anyhow::Result<Option<(CalendarDateTime, CalendarDateTime)>> {

1881

12

        if self.start.2 {

1882

            Ok(Some((

1883

12

                self.start.into(),

1884

12

                match &self.end {

1885

6

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

1886

6

                    PeriodEnd::Duration(duration) => {

1887

6

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

1888

6

                        cdt.add(duration)?

1889

1890

},

1891

)))

1892

        } else {

1893

            Ok(None)

1894

1895

12

1896

1897

1898

#[derive(Clone, Debug, PartialEq)]

1899

pub enum PeriodEnd {

1900

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

1901

    Duration(Duration),

1902

1903

1904

#[derive(Debug, PartialEq)]

1905

pub struct RecurrenceDateTimesProperty {

1906

    pub(crate) value: RecurrenceDateTimesPropertyValue,

1907

    pub(crate) params: Vec<Param>,

1908

1909

1910

#[derive(Debug, PartialEq)]

1911

pub enum RecurrenceDateTimesPropertyValue {

1912

    DateTimes(Vec<CalendarDateTime>),

1913

    Periods(Vec<Period>),

1914

1915

1916

impl_property_access!(

1917

    RecurrenceDateTimesProperty,

1918

    RecurrenceDateTimesPropertyValue

1919

);

1920

1921

pub struct RecurrenceDateTimesPropertyBuilder<P: AddComponentProperty> {

1922

    owner: P,

1923

    inner: RecurrenceDateTimesProperty,

1924

1925

1926

impl<P> RecurrenceDateTimesPropertyBuilder<P>

1927

where

1928

    P: AddComponentProperty,

1929

1930

60

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

1931

60

        let mut params = Vec::new();

1932

60

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

1933

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

1934

60

1935

1936

60

        RecurrenceDateTimesPropertyBuilder {

1937

60

            owner,

1938

60

            inner: RecurrenceDateTimesProperty {

1939

60

                value: RecurrenceDateTimesPropertyValue::DateTimes(date_times),

1940

60

                params,

1941

60

},

1942

60

1943

60

1944

1945

2

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

1946

2

        RecurrenceDateTimesPropertyBuilder {

1947

2

            owner,

1948

2

            inner: RecurrenceDateTimesProperty {

1949

2

                value: RecurrenceDateTimesPropertyValue::Periods(periods),

1950

2

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

1951

2

                    value: Value::Period,

1952

2

                })],

1953

2

},

1954

2

1955

2

1956

1957

    tz_id_param!();

1958

1959

    impl_finish_component_property_build!(ComponentProperty::RecurrenceDateTimes);

1960

1961

1962

impl_other_component_params_builder!(RecurrenceDateTimesPropertyBuilder<P>);

1963

1964

#[derive(Debug, PartialEq)]

1965

pub struct DateTimeCompletedProperty {

1966

    pub(crate) value: CalendarDateTime,

1967

    pub(crate) params: Vec<Param>,

1968

1969

1970

impl_property_access!(DateTimeCompletedProperty, CalendarDateTime);

1971

1972

pub struct CompletedPropertyBuilder<P: AddComponentProperty> {

1973

    owner: P,

1974

    inner: DateTimeCompletedProperty,

1975

1976

1977

impl<P> CompletedPropertyBuilder<P>

1978

where

1979

    P: AddComponentProperty,

1980

1981

12

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

1982

12

        CompletedPropertyBuilder {

1983

12

            owner,

1984

12

            inner: DateTimeCompletedProperty {

1985

12

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

1986

12

                params: Vec::new(),

1987

12

},

1988

12

1989

12

1990

1991

    add_is_utc!();

1992

1993

    impl_finish_component_property_build!(ComponentProperty::DateTimeCompleted);

1994

1995

1996

impl_other_component_params_builder!(CompletedPropertyBuilder<P>);

1997

1998

#[derive(Debug, PartialEq)]

1999

pub struct PercentCompleteProperty {

2000

    pub(crate) value: u8,

2001

    pub(crate) params: Vec<Param>,

2002

2003

2004

impl_property_access!(PercentCompleteProperty, u8);

2005

2006

pub struct PercentCompletePropertyBuilder<P: AddComponentProperty> {

2007

    owner: P,

2008

    inner: PercentCompleteProperty,

2009

2010

2011

impl<P> PercentCompletePropertyBuilder<P>

2012

where

2013

    P: AddComponentProperty,

2014

2015

12

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

2016

12

        PercentCompletePropertyBuilder {

2017

12

            owner,

2018

12

            inner: PercentCompleteProperty {

2019

12

                value,

2020

12

                params: Vec::new(),

2021

12

},

2022

12

2023

12

2024

2025

    impl_finish_component_property_build!(ComponentProperty::PercentComplete);

2026

2027

2028

impl_other_component_params_builder!(PercentCompletePropertyBuilder<P>);

2029

2030

#[derive(Debug, Clone, PartialEq)]

2031

pub struct DateTimeDueProperty {

2032

    pub(crate) value: CalendarDateTime,

2033

    pub(crate) params: Vec<Param>,

2034

2035

2036

impl_property_access!(DateTimeDueProperty, CalendarDateTime);

2037

2038

pub struct DateTimeDuePropertyBuilder<P: AddComponentProperty> {

2039

    owner: P,

2040

    inner: DateTimeDueProperty,

2041

2042

2043

impl<P> DateTimeDuePropertyBuilder<P>

2044

where

2045

    P: AddComponentProperty,

2046

2047

    pub(crate) fn new(

2048

        owner: P,

2049

        date: time::Date,

2050

        time: Option<time::Time>,

2051

    ) -> DateTimeDuePropertyBuilder<P> {

2052

        let mut params = Vec::new();

2053

2054

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

2055

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

2056

        if time.is_none() {

2057

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

2058

2059

2060

        DateTimeDuePropertyBuilder {

2061

            owner,

2062

            inner: DateTimeDueProperty {

2063

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

2064

                params,

2065

},

2066

2067

2068

2069

    tz_id_param!();

2070

2071

    add_is_utc!();

2072

2073

    impl_finish_component_property_build!(ComponentProperty::DateTimeDue);

2074

2075

2076

impl_other_component_params_builder!(DateTimeDuePropertyBuilder<P>);

2077

2078

#[derive(Debug, PartialEq)]

2079

pub struct FreeBusyTimeProperty {

2080

    pub(crate) value: Vec<Period>,

2081

    pub(crate) params: Vec<Param>,

2082

2083

2084

impl_property_access!(FreeBusyTimeProperty, Vec<Period>);

2085

2086

pub struct FreeBusyTimePropertyBuilder<P: AddComponentProperty> {

2087

    owner: P,

2088

    inner: FreeBusyTimeProperty,

2089

2090

2091

impl<P> FreeBusyTimePropertyBuilder<P>

2092

where

2093

    P: AddComponentProperty,

2094

2095

12

    pub(crate) fn new(

2096

12

        owner: P,

2097

12

        free_busy_time_type: FreeBusyTimeType,

2098

12

        value: Vec<Period>,

2099

12

    ) -> FreeBusyTimePropertyBuilder<P> {

2100

12

        FreeBusyTimePropertyBuilder {

2101

12

            owner,

2102

12

            inner: FreeBusyTimeProperty {

2103

12

                value,

2104

12

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

2105

12

                    fb_type: free_busy_time_type,

2106

12

                })],

2107

12

},

2108

12

2109

12

2110

2111

    impl_finish_component_property_build!(ComponentProperty::FreeBusyTime);

2112

2113

2114

impl_other_component_params_builder!(FreeBusyTimePropertyBuilder<P>);

2115

2116

#[derive(Debug, PartialEq)]

2117

pub struct TimeZoneIdProperty {

2118

    pub(crate) value: TimeZoneIdPropertyValue,

2119

    pub(crate) params: Vec<Param>,

2120

2121

2122

#[derive(Debug, Clone, PartialEq)]

2123

pub struct TimeZoneIdPropertyValue {

2124

    pub id: String,

2125

    pub unique_registry_id: bool,

2126

2127

2128

impl_property_access!(TimeZoneIdProperty, TimeZoneIdPropertyValue);

2129

2130

pub struct TimeZoneIdPropertyBuilder<P: AddComponentProperty> {

2131

    owner: P,

2132

    inner: TimeZoneIdProperty,

2133

2134

2135

impl<P> TimeZoneIdPropertyBuilder<P>

2136

where

2137

    P: AddComponentProperty,

2138

2139

12

    pub(crate) fn new(

2140

12

        owner: P,

2141

12

        value: String,

2142

12

        unique_registry_id: bool,

2143

12

    ) -> TimeZoneIdPropertyBuilder<P> {

2144

12

        TimeZoneIdPropertyBuilder {

2145

12

            owner,

2146

12

            inner: TimeZoneIdProperty {

2147

12

                value: TimeZoneIdPropertyValue {

2148

12

                    id: value,

2149

12

                    unique_registry_id,

2150

12

},

2151

12

                params: Vec::new(),

2152

12

},

2153

12

2154

12

2155

2156

    impl_finish_component_property_build!(ComponentProperty::TimeZoneId);

2157

2158

2159

impl_other_component_params_builder!(TimeZoneIdPropertyBuilder<P>);

2160

2161

#[derive(Debug, PartialEq)]

2162

pub struct TimeZoneUrlProperty {

2163

    pub(crate) value: String,

2164

    pub(crate) params: Vec<Param>,

2165

2166

2167

impl_property_access!(TimeZoneUrlProperty, String);

2168

2169

pub struct TimeZoneUrlPropertyBuilder<P: AddComponentProperty> {

2170

    owner: P,

2171

    inner: TimeZoneUrlProperty,

2172

2173

2174

impl<P> TimeZoneUrlPropertyBuilder<P>

2175

where

2176

    P: AddComponentProperty,

2177

2178

12

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

2179

12

        TimeZoneUrlPropertyBuilder {

2180

12

            owner,

2181

12

            inner: TimeZoneUrlProperty {

2182

12

                value,

2183

12

                params: Vec::new(),

2184

12

},

2185

12

2186

12

2187

2188

    impl_finish_component_property_build!(ComponentProperty::TimeZoneUrl);

2189

2190

2191

impl_other_component_params_builder!(TimeZoneUrlPropertyBuilder<P>);

2192

2193

#[derive(Debug, PartialEq)]

2194

pub struct TimeZoneOffset {

2195

    pub(crate) sign: i8,

2196

    pub(crate) hours: u8,

2197

    pub(crate) minutes: u8,

2198

    pub(crate) seconds: Option<u8>,

2199

2200

2201

impl TimeZoneOffset {

2202

48

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

2203

48

        TimeZoneOffset {

2204

48

            sign,

2205

48

            hours,

2206

48

            minutes,

2207

48

            seconds,

2208

48

2209

48

2210

2211

2212

#[derive(Debug, PartialEq)]

2213

pub struct TimeZoneOffsetToProperty {

2214

    pub(crate) value: TimeZoneOffset,

2215

    pub(crate) params: Vec<Param>,

2216

2217

2218

impl_property_access!(TimeZoneOffsetToProperty, TimeZoneOffset);

2219

2220

pub struct TimeZoneOffsetToPropertyBuilder<P: AddComponentProperty> {

2221

    owner: P,

2222

    inner: TimeZoneOffsetToProperty,

2223

2224

2225

impl<P> TimeZoneOffsetToPropertyBuilder<P>

2226

where

2227

    P: AddComponentProperty,

2228

2229

24

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

2230

24

        TimeZoneOffsetToPropertyBuilder {

2231

24

            owner,

2232

24

            inner: TimeZoneOffsetToProperty {

2233

24

                value: offset,

2234

24

                params: Vec::new(),

2235

24

},

2236

24

2237

24

2238

2239

    impl_finish_component_property_build!(ComponentProperty::TimeZoneOffsetTo);

2240

2241

2242

impl_other_component_params_builder!(TimeZoneOffsetToPropertyBuilder<P>);

2243

2244

#[derive(Debug, PartialEq)]

2245

pub struct TimeZoneOffsetFromProperty {

2246

    pub(crate) value: TimeZoneOffset,

2247

    pub(crate) params: Vec<Param>,

2248

2249

2250

impl_property_access!(TimeZoneOffsetFromProperty, TimeZoneOffset);

2251

2252

pub struct TimeZoneOffsetFromPropertyBuilder<P: AddComponentProperty> {

2253

    owner: P,

2254

    inner: TimeZoneOffsetFromProperty,

2255

2256

2257

impl<P> TimeZoneOffsetFromPropertyBuilder<P>

2258

where

2259

    P: AddComponentProperty,

2260

2261

24

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

2262

24

        TimeZoneOffsetFromPropertyBuilder {

2263

24

            owner,

2264

24

            inner: TimeZoneOffsetFromProperty {

2265

24

                value: offset,

2266

24

                params: Vec::new(),

2267

24

},

2268

24

2269

24

2270

2271

    impl_finish_component_property_build!(ComponentProperty::TimeZoneOffsetFrom);

2272

2273

2274

impl_other_component_params_builder!(TimeZoneOffsetFromPropertyBuilder<P>);

2275

2276

#[derive(Debug, PartialEq)]

2277

pub struct TimeZoneNameProperty {

2278

    pub(crate) value: String,

2279

    pub(crate) params: Vec<Param>,

2280

2281

2282

impl_property_access!(TimeZoneNameProperty, String);

2283

2284

pub struct TimeZoneNamePropertyBuilder<P: AddComponentProperty> {

2285

    owner: P,

2286

    inner: TimeZoneNameProperty,

2287

2288

2289

impl<P> TimeZoneNamePropertyBuilder<P>

2290

where

2291

    P: AddComponentProperty,

2292

2293

24

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

2294

24

        TimeZoneNamePropertyBuilder {

2295

24

            owner,

2296

24

            inner: TimeZoneNameProperty {

2297

24

                value,

2298

24

                params: Vec::new(),

2299

24

},

2300

24

2301

24

2302

2303

    language_param!();

2304

2305

    impl_finish_component_property_build!(ComponentProperty::TimeZoneName);

2306

2307

2308

impl_other_component_params_builder!(TimeZoneNamePropertyBuilder<P>);

2309

2310

#[derive(Debug, Clone, PartialEq)]

2311

pub enum Action {

2312

    Audio,

2313

    Display,

2314

    Email,

2315

    XName(String),

2316

    IanaToken(String),

2317

2318

2319

#[derive(Debug, PartialEq)]

2320

pub struct ActionProperty {

2321

    pub(crate) value: Action,

2322

    pub(crate) params: Vec<Param>,

2323

2324

2325

impl_property_access!(ActionProperty, Action);

2326

2327

pub struct ActionPropertyBuilder<P: AddComponentProperty> {

2328

    owner: P,

2329

    inner: ActionProperty,

2330

2331

2332

impl<P> ActionPropertyBuilder<P>

2333

where

2334

    P: AddComponentProperty,

2335

2336

16

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

2337

16

        ActionPropertyBuilder {

2338

16

            owner,

2339

16

            inner: ActionProperty {

2340

16

                value,

2341

16

                params: Vec::new(),

2342

16

},

2343

16

2344

16

2345

2346

    impl_finish_component_property_build!(ComponentProperty::Action);

2347

2348

2349

impl_other_component_params_builder!(ActionPropertyBuilder<P>);

2350

2351

#[derive(Debug)]

2352

pub struct RelativeTriggerProperty {

2353

    pub(crate) value: Duration,

2354

    pub(crate) params: Vec<Param>,

2355

2356

2357

pub struct RelativeTriggerPropertyBuilder<P: AddComponentProperty> {

2358

    owner: P,

2359

    inner: RelativeTriggerProperty,

2360

2361

2362

impl<P> RelativeTriggerPropertyBuilder<P>

2363

where

2364

    P: AddComponentProperty,

2365

2366

8

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

2367

8

        RelativeTriggerPropertyBuilder {

2368

8

            owner,

2369

8

            inner: RelativeTriggerProperty {

2370

8

                value,

2371

8

                params: Vec::new(),

2372

8

},

2373

8

2374

8

2375

2376

4

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

2377

4

        self.inner

2378

4

            .params

2379

4

            .push(Param::TriggerRelationship(TriggerRelationshipParam {

2380

4

                trigger_relationship,

2381

4

            }));

2382

4

        self

2383

4

2384

2385

8

    pub fn finish_property(mut self) -> P {

2386

8

        self.owner

2387

8

            .add_property(ComponentProperty::Trigger(TriggerProperty {

2388

8

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

2389

8

                params: self.inner.params,

2390

8

            }));

2391

8

        self.owner

2392

8

2393

2394

2395

impl_other_component_params_builder!(RelativeTriggerPropertyBuilder<P>);

2396

2397

#[derive(Debug)]

2398

pub(crate) struct AbsoluteTriggerProperty {

2399

    pub(crate) value: CalendarDateTime,

2400

    pub(crate) params: Vec<Param>,

2401

2402

2403

pub struct AbsoluteTriggerPropertyBuilder<P: AddComponentProperty> {

2404

    owner: P,

2405

    inner: AbsoluteTriggerProperty,

2406

2407

2408

impl<P> AbsoluteTriggerPropertyBuilder<P>

2409

where

2410

    P: AddComponentProperty,

2411

2412

8

    pub(crate) fn new(

2413

8

        owner: P,

2414

8

        date: time::Date,

2415

8

        time: time::Time,

2416

8

    ) -> AbsoluteTriggerPropertyBuilder<P> {

2417

8

        AbsoluteTriggerPropertyBuilder {

2418

8

            owner,

2419

8

            inner: AbsoluteTriggerProperty {

2420

8

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

2421

8

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

2422

8

                    value: Value::DateTime,

2423

8

                })],

2424

8

},

2425

8

2426

8

2427

2428

    add_is_utc!();

2429

2430

8

    pub fn finish_property(mut self) -> P {

2431

8

        self.owner

2432

8

            .add_property(ComponentProperty::Trigger(TriggerProperty {

2433

8

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

2434

8

                params: self.inner.params,

2435

8

            }));

2436

8

        self.owner

2437

8

2438

2439

2440

impl_other_component_params_builder!(AbsoluteTriggerPropertyBuilder<P>);

2441

2442

#[derive(Debug, PartialEq)]

2443

pub struct RepeatProperty {

2444

    pub(crate) value: u32,

2445

    pub(crate) params: Vec<Param>,

2446

2447

2448

impl_property_access!(RepeatProperty, u32);

2449

2450

pub struct RepeatPropertyBuilder<P: AddComponentProperty> {

2451

    owner: P,

2452

    inner: RepeatProperty,

2453

2454

2455

impl<P> RepeatPropertyBuilder<P>

2456

where

2457

    P: AddComponentProperty,

2458

2459

16

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

2460

16

        RepeatPropertyBuilder {

2461

16

            owner,

2462

16

            inner: RepeatProperty {

2463

16

                value,

2464

16

                params: Vec::new(),

2465

16

},

2466

16

2467

16

2468

2469

    impl_finish_component_property_build!(ComponentProperty::Repeat);

2470

2471

2472

impl_other_component_params_builder!(RepeatPropertyBuilder<P>);