-
Notifications
You must be signed in to change notification settings - Fork 277
/
value.hpp
1747 lines (1519 loc) · 59.6 KB
/
value.hpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// ***************************************************************** -*- C++ -*-
/*
* Copyright (C) 2004-2021 Exiv2 authors
* This program is part of the Exiv2 distribution.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, 5th Floor, Boston, MA 02110-1301 USA.
*/
#ifndef VALUE_HPP_
#define VALUE_HPP_
// *****************************************************************************
#include "exiv2lib_export.h"
// included header files
#include "types.hpp"
// + standard includes
#include <map>
#include <iomanip>
#include <memory>
#include <cstring>
#include <climits>
// *****************************************************************************
// namespace extensions
namespace Exiv2 {
// *****************************************************************************
// class definitions
/*!
@brief Common interface for all types of values used with metadata.
The interface provides a uniform way to access values independent of
their actual C++ type for simple tasks like reading the values from a
string or data buffer. For other tasks, like modifying values you may
need to downcast it to a specific subclass to access its interface.
*/
class EXIV2API Value {
public:
//! Shortcut for a %Value auto pointer.
typedef std::auto_ptr<Value> AutoPtr;
//! @name Creators
//@{
//! Constructor, taking a type id to initialize the base class with
explicit Value(TypeId typeId);
//! Virtual destructor.
virtual ~Value();
//@}
//! @name Manipulators
//@{
/*!
@brief Read the value from a character buffer.
@param buf Pointer to the data buffer to read from
@param len Number of bytes in the data buffer
@param byteOrder Applicable byte order (little or big endian).
@return 0 if successful.
*/
virtual int read(const byte* buf, long len, ByteOrder byteOrder) =0;
/*!
@brief Set the value from a string buffer. The format of the string
corresponds to that of the write() method, i.e., a string
obtained through the write() method can be read by this
function.
@param buf The string to read from.
@return 0 if successful.
*/
virtual int read(const std::string& buf) =0;
/*!
@brief Set the data area, if the value has one by copying (cloning)
the buffer pointed to by buf.
Values may have a data area, which can contain additional
information besides the actual value. This method is used to set such
a data area.
@param buf Pointer to the source data area
@param len Size of the data area
@return Return -1 if the value has no data area, else 0.
*/
virtual int setDataArea(const byte* buf, long len);
//@}
//! @name Accessors
//@{
//! Return the type identifier (Exif data format type).
TypeId typeId() const { return type_; }
/*!
@brief Return an auto-pointer to a copy of itself (deep copy).
The caller owns this copy and the auto-pointer ensures that
it will be deleted.
*/
AutoPtr clone() const { return AutoPtr(clone_()); }
/*!
@brief Write value to a data buffer.
The user must ensure that the buffer has enough memory. Otherwise
the call results in undefined behaviour.
@param buf Data buffer to write to.
@param byteOrder Applicable byte order (little or big endian).
@return Number of bytes written.
*/
virtual long copy(byte* buf, ByteOrder byteOrder) const =0;
//! Return the number of components of the value
virtual long count() const =0;
//! Return the size of the value in bytes
virtual long size() const =0;
/*!
@brief Write the value to an output stream. You do not usually have
to use this function; it is used for the implementation of
the output operator for %Value,
operator<<(std::ostream &os, const Value &value).
*/
virtual std::ostream& write(std::ostream& os) const =0;
/*!
@brief Return the value as a string. Implemented in terms of
write(std::ostream& os) const of the concrete class.
*/
std::string toString() const;
/*!
@brief Return the <EM>n</EM>-th component of the value as a string.
The default implementation returns toString(). The behaviour
of this method may be undefined if there is no <EM>n</EM>-th
component.
*/
virtual std::string toString(long n) const;
/*!
@brief Convert the <EM>n</EM>-th component of the value to a long.
The behaviour of this method may be undefined if there is no
<EM>n</EM>-th component.
@return The converted value.
*/
virtual long toLong(long n =0) const =0;
/*!
@brief Convert the <EM>n</EM>-th component of the value to a float.
The behaviour of this method may be undefined if there is no
<EM>n</EM>-th component.
@return The converted value.
*/
virtual float toFloat(long n =0) const =0;
/*!
@brief Convert the <EM>n</EM>-th component of the value to a Rational.
The behaviour of this method may be undefined if there is no
<EM>n</EM>-th component.
@return The converted value.
*/
virtual Rational toRational(long n =0) const =0;
//! Return the size of the data area, 0 if there is none.
virtual long sizeDataArea() const;
/*!
@brief Return a copy of the data area if the value has one. The
caller owns this copy and DataBuf ensures that it will be
deleted.
Values may have a data area, which can contain additional
information besides the actual value. This method is used to access
such a data area.
@return A DataBuf containing a copy of the data area or an empty
DataBuf if the value does not have a data area assigned.
*/
virtual DataBuf dataArea() const;
/*!
@brief Check the \em ok status indicator. After a to<Type> conversion,
this indicator shows whether the conversion was successful.
*/
bool ok() const { return ok_; }
//@}
/*!
@brief A (simple) factory to create a Value type.
The following Value subclasses are created depending on typeId:<BR><BR>
<TABLE>
<TR><TD><B>typeId</B></TD><TD><B>%Value subclass</B></TD></TR>
<TR><TD><CODE>invalidTypeId</CODE></TD><TD>%DataValue(invalidTypeId)</TD></TR>
<TR><TD><CODE>unsignedByte</CODE></TD><TD>%DataValue(unsignedByte)</TD></TR>
<TR><TD><CODE>asciiString</CODE></TD><TD>%AsciiValue</TD></TR>
<TR><TD><CODE>string</CODE></TD><TD>%StringValue</TD></TR>
<TR><TD><CODE>unsignedShort</CODE></TD><TD>%ValueType < uint16_t ></TD></TR>
<TR><TD><CODE>unsignedLong</CODE></TD><TD>%ValueType < uint32_t ></TD></TR>
<TR><TD><CODE>unsignedRational</CODE></TD><TD>%ValueType < URational ></TD></TR>
<TR><TD><CODE>invalid6</CODE></TD><TD>%DataValue(invalid6)</TD></TR>
<TR><TD><CODE>undefined</CODE></TD><TD>%DataValue</TD></TR>
<TR><TD><CODE>signedShort</CODE></TD><TD>%ValueType < int16_t ></TD></TR>
<TR><TD><CODE>signedLong</CODE></TD><TD>%ValueType < int32_t ></TD></TR>
<TR><TD><CODE>signedRational</CODE></TD><TD>%ValueType < Rational ></TD></TR>
<TR><TD><CODE>tiffFloat</CODE></TD><TD>%ValueType < float ></TD></TR>
<TR><TD><CODE>tiffDouble</CODE></TD><TD>%ValueType < double ></TD></TR>
<TR><TD><CODE>tiffIfd</CODE></TD><TD>%ValueType < uint32_t ></TD></TR>
<TR><TD><CODE>date</CODE></TD><TD>%DateValue</TD></TR>
<TR><TD><CODE>time</CODE></TD><TD>%TimeValue</TD></TR>
<TR><TD><CODE>comment</CODE></TD><TD>%CommentValue</TD></TR>
<TR><TD><CODE>xmpText</CODE></TD><TD>%XmpTextValue</TD></TR>
<TR><TD><CODE>xmpBag</CODE></TD><TD>%XmpArrayValue</TD></TR>
<TR><TD><CODE>xmpSeq</CODE></TD><TD>%XmpArrayValue</TD></TR>
<TR><TD><CODE>xmpAlt</CODE></TD><TD>%XmpArrayValue</TD></TR>
<TR><TD><CODE>langAlt</CODE></TD><TD>%LangAltValue</TD></TR>
<TR><TD><EM>default</EM></TD><TD>%DataValue(typeId)</TD></TR>
</TABLE>
@param typeId Type of the value.
@return Auto-pointer to the newly created Value. The caller owns this
copy and the auto-pointer ensures that it will be deleted.
*/
static AutoPtr create(TypeId typeId);
protected:
/*!
@brief Assignment operator. Protected so that it can only be used
by subclasses but not directly.
*/
Value& operator=(const Value& rhs);
// DATA
mutable bool ok_; //!< Indicates the status of the previous to<Type> conversion
private:
//! Internal virtual copy constructor.
virtual Value* clone_() const =0;
// DATA
TypeId type_; //!< Type of the data
}; // class Value
//! Output operator for Value types
inline std::ostream& operator<<(std::ostream& os, const Value& value)
{
return value.write(os);
}
//! %Value for an undefined data type.
class EXIV2API DataValue : public Value {
public:
//! Shortcut for a %DataValue auto pointer.
typedef std::auto_ptr<DataValue> AutoPtr;
explicit DataValue(TypeId typeId =undefined);
DataValue(const byte* buf,
long len, ByteOrder byteOrder =invalidByteOrder,
TypeId typeId =undefined);
virtual ~DataValue();
//! @name Manipulators
//@{
/*!
@brief Read the value from a character buffer.
@note The byte order is required by the interface but not
used by this method, so just use the default.
@param buf Pointer to the data buffer to read from
@param len Number of bytes in the data buffer
@param byteOrder Byte order. Not needed.
@return 0 if successful.
*/
virtual int read(const byte* buf,
long len,
ByteOrder byteOrder =invalidByteOrder);
//! Set the data from a string of integer values (e.g., "0 1 2 3")
virtual int read(const std::string& buf);
//@}
//! @name Accessors
//@{
AutoPtr clone() const { return AutoPtr(clone_()); }
/*!
@brief Write value to a character data buffer.
@note The byte order is required by the interface but not used by this
method, so just use the default.
The user must ensure that the buffer has enough memory. Otherwise
the call results in undefined behaviour.
@param buf Data buffer to write to.
@param byteOrder Byte order. Not needed.
@return Number of characters written.
*/
virtual long copy(byte* buf, ByteOrder byteOrder =invalidByteOrder) const;
virtual long count() const;
virtual long size() const;
virtual std::ostream& write(std::ostream& os) const;
/*!
@brief Return the <EM>n</EM>-th component of the value as a string.
The behaviour of this method may be undefined if there is no
<EM>n</EM>-th component.
*/
virtual std::string toString(long n) const;
virtual long toLong(long n =0) const;
virtual float toFloat(long n =0) const;
virtual Rational toRational(long n =0) const;
//@}
private:
//! Internal virtual copy constructor.
virtual DataValue* clone_() const;
//! Type used to store the data.
typedef std::vector<byte> ValueType;
// DATA
ValueType value_; //!< Stores the data value
}; // class DataValue
/*!
@brief Abstract base class for a string based %Value type.
Uses a std::string to store the value and implements defaults for
most operations.
*/
class EXIV2API StringValueBase : public Value {
public:
//! Shortcut for a %StringValueBase auto pointer.
typedef std::auto_ptr<StringValueBase> AutoPtr;
//! @name Creators
//@{
//! Constructor for subclasses
explicit StringValueBase(TypeId typeId);
//! Constructor for subclasses
StringValueBase(TypeId typeId, const std::string& buf);
//! Copy constructor
StringValueBase(const StringValueBase& rhs);
//! Virtual destructor.
virtual ~StringValueBase();
//@}
//! @name Manipulators
//@{
//! Read the value from buf. This default implementation uses buf as it is.
virtual int read(const std::string& buf);
/*!
@brief Read the value from a character buffer.
@note The byte order is required by the interface but not used by this
method, so just use the default.
@param buf Pointer to the data buffer to read from
@param len Number of bytes in the data buffer
@param byteOrder Byte order. Not needed.
@return 0 if successful.
*/
virtual int read(const byte* buf,
long len,
ByteOrder byteOrder =invalidByteOrder);
//@}
//! @name Accessors
//@{
AutoPtr clone() const { return AutoPtr(clone_()); }
/*!
@brief Write value to a character data buffer.
The user must ensure that the buffer has enough memory. Otherwise
the call results in undefined behaviour.
@note The byte order is required by the interface but not used by this
method, so just use the default.
@param buf Data buffer to write to.
@param byteOrder Byte order. Not used.
@return Number of characters written.
*/
virtual long copy(byte* buf, ByteOrder byteOrder =invalidByteOrder) const;
virtual long count() const;
virtual long size() const;
virtual long toLong(long n =0) const;
virtual float toFloat(long n =0) const;
virtual Rational toRational(long n =0) const;
virtual std::ostream& write(std::ostream& os) const;
//@}
protected:
//! Assignment operator.
StringValueBase& operator=(const StringValueBase& rhs);
//! Internal virtual copy constructor.
virtual StringValueBase* clone_() const =0;
public:
// DATA
std::string value_; //!< Stores the string value.
}; // class StringValueBase
/*!
@brief %Value for string type.
This can be a plain Ascii string or a multipe byte encoded string. It is
left to caller to decode and encode the string to and from readable
text if that is required.
*/
class EXIV2API StringValue : public StringValueBase {
public:
//! Shortcut for a %StringValue auto pointer.
typedef std::auto_ptr<StringValue> AutoPtr;
//! @name Creators
//@{
//! Default constructor.
StringValue();
//! Constructor
explicit StringValue(const std::string& buf);
//! Virtual destructor.
virtual ~StringValue();
//@}
//! @name Accessors
//@{
AutoPtr clone() const { return AutoPtr(clone_()); }
//@}
private:
//! Internal virtual copy constructor.
virtual StringValue* clone_() const;
}; // class StringValue
/*!
@brief %Value for an Ascii string type.
This class is for null terminated single byte Ascii strings.
This class also ensures that the string is null terminated.
*/
class EXIV2API AsciiValue : public StringValueBase {
public:
//! Shortcut for a %AsciiValue auto pointer.
typedef std::auto_ptr<AsciiValue> AutoPtr;
//! @name Creators
//@{
//! Default constructor.
AsciiValue();
//! Constructor
explicit AsciiValue(const std::string& buf);
//! Virtual destructor.
virtual ~AsciiValue();
//@}
//! @name Manipulators
//@{
using StringValueBase::read;
/*!
@brief Set the value to that of the string buf. Overrides base class
to append a terminating '\\0' character if buf doesn't end
with '\\0'.
*/
virtual int read(const std::string& buf);
//@}
//! @name Accessors
//@{
AutoPtr clone() const { return AutoPtr(clone_()); }
/*!
@brief Write the ASCII value up to the the first '\\0' character to an
output stream. Any further characters are ignored and not
written to the output stream.
*/
virtual std::ostream& write(std::ostream& os) const;
//@}
private:
//! Internal virtual copy constructor.
virtual AsciiValue* clone_() const;
}; // class AsciiValue
/*!
@brief %Value for an Exif comment.
This can be a plain Ascii string or a multipe byte encoded string. The
comment is expected to be encoded in the character set indicated (default
undefined), but this is not checked. It is left to caller to decode and
encode the string to and from readable text if that is required.
*/
class EXIV2API CommentValue : public StringValueBase {
public:
//! Character set identifiers for the character sets defined by %Exif
enum CharsetId { ascii, jis, unicode, undefined,
invalidCharsetId, lastCharsetId };
//! Information pertaining to the defined character sets
struct CharsetTable {
//! Constructor
CharsetTable(CharsetId charsetId,
const char* name,
const char* code);
CharsetId charsetId_; //!< Charset id
const char* name_; //!< Name of the charset
const char* code_; //!< Code of the charset
}; // struct CharsetTable
//! Charset information lookup functions. Implemented as a static class.
class EXIV2API CharsetInfo {
//! Prevent construction: not implemented.
CharsetInfo() {}
//! Prevent copy-construction: not implemented.
CharsetInfo(const CharsetInfo&);
//! Prevent assignment: not implemented.
CharsetInfo& operator=(const CharsetInfo&);
public:
//! Return the name for a charset id
static const char* name(CharsetId charsetId);
//! Return the code for a charset id
static const char* code(CharsetId charsetId);
//! Return the charset id for a name
static CharsetId charsetIdByName(const std::string& name);
//! Return the charset id for a code
static CharsetId charsetIdByCode(const std::string& code);
private:
static const CharsetTable charsetTable_[];
}; // class CharsetInfo
//! Shortcut for a %CommentValue auto pointer.
typedef std::auto_ptr<CommentValue> AutoPtr;
//! @name Creators
//@{
//! Default constructor.
CommentValue();
//! Constructor, uses read(const std::string& comment)
explicit CommentValue(const std::string& comment);
//! Virtual destructor.
virtual ~CommentValue();
//@}
//! @name Manipulators
//@{
/*!
@brief Read the value from a comment
The format of \em comment is:
<BR>
<CODE>[charset=["]Ascii|Jis|Unicode|Undefined["] ]comment</CODE>
<BR>
The default charset is Undefined.
@return 0 if successful<BR>
1 if an invalid character set is encountered
*/
int read(const std::string& comment);
/*!
@brief Read the comment from a byte buffer.
*/
int read(const byte* buf, long len, ByteOrder byteOrder);
//@}
//! @name Accessors
//@{
AutoPtr clone() const { return AutoPtr(clone_()); }
long copy(byte* buf, ByteOrder byteOrder) const;
/*!
@brief Write the comment in a format which can be read by
read(const std::string& comment).
*/
std::ostream& write(std::ostream& os) const;
/*!
@brief Return the comment (without a charset="..." prefix)
The comment is decoded to UTF-8. For Exif UNICODE comments, the
function makes an attempt to correctly determine the character
encoding of the value. Alternatively, the optional \em encoding
parameter can be used to specify it.
@param encoding Optional argument to specify the character encoding
that the comment is encoded in, as an iconv(3) name. Only used
for Exif UNICODE comments.
@return A string containing the comment converted to UTF-8.
*/
std::string comment(const char* encoding =0) const;
/*!
@brief Determine the character encoding that was used to encode the
UNICODE comment value as an iconv(3) name.
If the comment \em c starts with a BOM, the BOM is interpreted and
removed from the string.
Todo: Implement rules to guess if the comment is UTF-8 encoded.
*/
const char* detectCharset(std::string& c) const;
//! Return the Exif charset id of the comment
CharsetId charsetId() const;
//@}
private:
//! Internal virtual copy constructor.
virtual CommentValue* clone_() const;
public:
// DATA
ByteOrder byteOrder_; //!< Byte order of the comment string that was read
}; // class CommentValue
/*!
@brief Base class for all Exiv2 values used to store XMP property values.
*/
class EXIV2API XmpValue : public Value {
public:
//! Shortcut for a %XmpValue auto pointer.
typedef std::auto_ptr<XmpValue> AutoPtr;
//! XMP array types.
enum XmpArrayType { xaNone, xaAlt, xaBag, xaSeq };
//! XMP structure indicator.
enum XmpStruct { xsNone, xsStruct };
//! @name Creators
//@{
explicit XmpValue(TypeId typeId);
//@}
//! @name Accessors
//@{
//! Return XMP array type, indicates if an XMP value is an array.
XmpArrayType xmpArrayType() const;
//! Return XMP struct, indicates if an XMP value is a structure.
XmpStruct xmpStruct() const;
virtual long size() const;
/*!
@brief Write value to a character data buffer.
The user must ensure that the buffer has enough memory. Otherwise
the call results in undefined behaviour.
@note The byte order is required by the interface but not used by this
method, so just use the default.
@param buf Data buffer to write to.
@param byteOrder Byte order. Not used.
@return Number of characters written.
*/
virtual long copy(byte* buf, ByteOrder byteOrder =invalidByteOrder) const;
//@}
//! @name Manipulators
//@{
//! Set the XMP array type to indicate that an XMP value is an array.
void setXmpArrayType(XmpArrayType xmpArrayType);
//! Set the XMP struct type to indicate that an XMP value is a structure.
void setXmpStruct(XmpStruct xmpStruct =xsStruct);
/*!
@brief Read the value from a character buffer.
Uses read(const std::string& buf)
@note The byte order is required by the interface but not used by this
method, so just use the default.
@param buf Pointer to the data buffer to read from
@param len Number of bytes in the data buffer
@param byteOrder Byte order. Not needed.
@return 0 if successful.
*/
virtual int read(const byte* buf,
long len,
ByteOrder byteOrder =invalidByteOrder);
virtual int read(const std::string& buf) =0;
//@}
/*!
@brief Return XMP array type for an array Value TypeId, xaNone if
\em typeId is not an XMP array value type.
*/
static XmpArrayType xmpArrayType(TypeId typeId);
protected:
/*!
@brief Assignment operator. Protected so that it can only be used
by subclasses but not directly.
*/
XmpValue& operator=(const XmpValue& rhs);
private:
// DATA
XmpArrayType xmpArrayType_; //!< Type of XMP array
XmpStruct xmpStruct_; //!< XMP structure indicator
}; // class XmpValue
/*!
@brief %Value type suitable for simple XMP properties and
XMP nodes of complex types which are not parsed into
specific values.
Uses a std::string to store the value.
*/
class EXIV2API XmpTextValue : public XmpValue {
public:
//! Shortcut for a %XmpTextValue auto pointer.
typedef std::auto_ptr<XmpTextValue> AutoPtr;
//! @name Creators
//@{
//! Constructor.
XmpTextValue();
//! Constructor, reads the value from a string.
explicit XmpTextValue(const std::string& buf);
//@}
//! @name Manipulators
//@{
using XmpValue::read;
/*!
@brief Read a simple property value from \em buf to set the value.
Sets the value to the contents of \em buf. A optional keyword,
\em type is supported to set the XMP value type. This is useful for
complex value types for which Exiv2 does not have direct support.
The format of \em buf is:
<BR>
<CODE>[type=["]Alt|Bag|Seq|Struct["] ]text</CODE>
<BR>
@return 0 if successful.
*/
virtual int read(const std::string& buf);
//@}
//! @name Accessors
//@{
AutoPtr clone() const;
long size() const;
virtual long count() const;
/*!
@brief Convert the value to a long.
The optional parameter \em n is not used and is ignored.
@return The converted value.
*/
virtual long toLong(long n =0) const;
/*!
@brief Convert the value to a float.
The optional parameter \em n is not used and is ignored.
@return The converted value.
*/
virtual float toFloat(long n =0) const;
/*!
@brief Convert the value to a Rational.
The optional parameter \em n is not used and is ignored.
@return The converted value.
*/
virtual Rational toRational(long n =0) const;
virtual std::ostream& write(std::ostream& os) const;
//@}
private:
//! Internal virtual copy constructor.
virtual XmpTextValue* clone_() const;
public:
// DATA
std::string value_; //!< Stores the string values.
}; // class XmpTextValue
/*!
@brief %Value type for simple arrays. Each item in the array is a simple
value, without qualifiers. The array may be an ordered (\em seq),
unordered (\em bag) or alternative array (\em alt). The array
items must not contain qualifiers. For language alternatives use
LangAltValue.
Uses a vector of std::string to store the value(s).
*/
class EXIV2API XmpArrayValue : public XmpValue {
public:
//! Shortcut for a %XmpArrayValue auto pointer.
typedef std::auto_ptr<XmpArrayValue> AutoPtr;
//! @name Creators
//@{
//! Constructor. \em typeId can be one of xmpBag, xmpSeq or xmpAlt.
explicit XmpArrayValue(TypeId typeId =xmpBag);
//@}
//! @name Manipulators
//@{
using XmpValue::read;
/*!
@brief Read a simple property value from \em buf and append it
to the value.
Appends \em buf to the value after the last existing array element.
Subsequent calls will therefore populate multiple array elements in
the order they are read.
@return 0 if successful.
*/
virtual int read(const std::string& buf);
//@}
//! @name Accessors
//@{
AutoPtr clone() const;
virtual long count() const;
/*!
@brief Return the <EM>n</EM>-th component of the value as a string.
The behaviour of this method may be undefined if there is no
<EM>n</EM>-th component.
*/
virtual std::string toString(long n) const;
virtual long toLong(long n =0) const;
virtual float toFloat(long n =0) const;
virtual Rational toRational(long n =0) const;
/*!
@brief Write all elements of the value to \em os, separated by commas.
@note The output of this method cannot directly be used as the parameter
for read().
*/
virtual std::ostream& write(std::ostream& os) const;
//@}
private:
//! Internal virtual copy constructor.
virtual XmpArrayValue* clone_() const;
std::vector<std::string> value_; //!< Stores the string values.
}; // class XmpArrayValue
/*!
@brief %LangAltValueComparator
#1058
https://www.adobe.com/content/dam/Adobe/en/devnet/xmp/pdfs/XMPSpecificationPart1.pdf
XMP spec chapter B.4 (page 42) the xml:lang qualifier is to be compared case insensitive.
*/
struct LangAltValueComparator {
//! LangAltValueComparator comparison case insensitive function
bool operator() (const std::string& str1, const std::string& str2) const
{
int result = str1.size() < str2.size() ? 1
: str1.size() > str2.size() ? -1
: 0
;
std::string::const_iterator c1 = str1.begin();
std::string::const_iterator c2 = str2.begin();
if ( result==0 ) for (
; result==0 && c1 != str1.end()
; ++c1, ++c2
) {
result = tolower(*c1) < tolower(*c2) ? 1
: tolower(*c1) > tolower(*c2) ? -1
: 0
;
}
return result < 0 ;
}
};
/*!
@brief %Value type for XMP language alternative properties.
A language alternative is an array consisting of simple text values,
each of which has a language qualifier.
*/
class EXIV2API LangAltValue : public XmpValue {
public:
//! Shortcut for a %LangAltValue auto pointer.
typedef std::auto_ptr<LangAltValue> AutoPtr;
//! @name Creators
//@{
//! Constructor.
LangAltValue();
//! Constructor, reads the value from a string.
explicit LangAltValue(const std::string& buf);
//@}
//! @name Manipulators
//@{
using XmpValue::read;
/*!
@brief Read a simple property value from \em buf and append it
to the value.
Appends \em buf to the value after the last existing array element.
Subsequent calls will therefore populate multiple array elements in
the order they are read.
The format of \em buf is:
<BR>
<CODE>[lang=["]language code["] ]text</CODE>
<BR>
The XMP default language code <CODE>x-default</CODE> is used if
\em buf doesn't start with the keyword <CODE>lang</CODE>.
@return 0 if successful.
*/
virtual int read(const std::string& buf);
//@}
//! @name Accessors
//@{
AutoPtr clone() const;
virtual long count() const;
/*!
@brief Return the text value associated with the default language
qualifier \c x-default. The parameter \em n is not used, but
it is suggested that only 0 is passed in. Returns an empty
string and sets the ok-flag to \c false if there is no
default value.
*/
virtual std::string toString(long n) const;
/*!
@brief Return the text value associated with the language qualifier
\em qualifier. Returns an empty string and sets the ok-flag
to \c false if there is no entry for the language qualifier.
*/
std::string toString(const std::string& qualifier) const;
virtual long toLong(long n =0) const;
virtual float toFloat(long n =0) const;
virtual Rational toRational(long n =0) const;
/*!
@brief Write all elements of the value to \em os, separated by commas.
@note The output of this method cannot directly be used as the parameter
for read().
*/
virtual std::ostream& write(std::ostream& os) const;
//@}
private:
//! Internal virtual copy constructor.
virtual LangAltValue* clone_() const;
public:
//! Type used to store language alternative arrays.
typedef std::map<std::string, std::string,LangAltValueComparator> ValueType;
// DATA
/*!
@brief Map to store the language alternative values. The language
qualifier is used as the key for the map entries.
*/
ValueType value_;
}; // class LangAltValue
/*!
@brief %Value for simple ISO 8601 dates
This class is limited to parsing simple date strings in the ISO 8601
format CCYYMMDD (century, year, month, day).
*/
class EXIV2API DateValue : public Value {
public:
//! Shortcut for a %DateValue auto pointer.
typedef std::auto_ptr<DateValue> AutoPtr;
//! @name Creators
//@{
//! Default constructor.
DateValue();
//! Constructor
DateValue(int year, int month, int day);
//! Virtual destructor.
virtual ~DateValue();
//@}
//! Simple Date helper structure
struct EXIV2API Date {
Date() : year(0), month(0), day(0) {}
int year; //!< Year
int month; //!< Month
int day; //!< Day
};