Exiv2 Namespace Reference

Provides classes and functions to encode and decode Exif and Iptc data. The libexiv2 API consists of the objects of this namespace. More...

Namespaces

namespace  ImageType
 Supported image formats.
 

Classes

class  AsfVideo
 Class to access ASF video files. More...
 
class  BasicIo
 An interface for simple binary IO. More...
 
class  IoCloser
 Utility class that closes a BasicIo instance upon destruction. Meant to be used as a stack variable in functions that need to ensure BasicIo instances get closed. Useful when functions return errors from many locations. More...
 
class  FileIo
 Provides binary file IO by implementing the BasicIo interface. More...
 
class  MemIo
 Provides binary IO on blocks of memory by implementing the BasicIo interface. A copy-on-write implementation ensures that the data passed in is only copied when necessary, i.e., as soon as data is written to the MemIo. The original data is only used for reading. If writes are performed, the changed data can be retrieved using the read methods (since the data used in construction is never modified). More...
 
class  XPathIo
 Provides binary IO for the data from stdin and data uri path. More...
 
class  BlockMap
 Utility class provides the block mapping to the part of data. This avoids allocating a single contiguous block of memory to the big data. More...
 
class  RemoteIo
 Provides remote binary file IO by implementing the BasicIo interface. This is an abstract class. The logics for remote access are implemented in HttpIo, CurlIo, SshIo which are the derived classes of RemoteIo. More...
 
class  HttpIo
 Provides the http read/write access for the RemoteIo. More...
 
class  BmpImage
 Class to access Windows bitmaps. This is just a stub - we only read width and height. More...
 
class  Cr2Image
 Class to access raw Canon CR2 images. Exif metadata is supported directly, IPTC is read from the Exif data, if present. More...
 
class  Cr2Parser
 Stateless parser class for data in CR2 format. Images use this class to decode and encode CR2 data. See class TiffParser for details. More...
 
class  CrwImage
 Class to access raw Canon CRW images. Only Exif metadata and a comment are supported. CRW format does not contain IPTC metadata. More...
 
class  CrwParser
 
struct  RecordInfo
 Details of an IPTC record. More...
 
struct  DataSet
 Details of an IPTC dataset. More...
 
class  IptcDataSets
 IPTC dataset reference, implemented as a static class. More...
 
class  IptcKey
 Concrete keys for IPTC metadata. More...
 
class  EpsImage
 Class to access EPS images. More...
 
class  LogMsg
 Class for a log message, used by the library. Applications can set the log level and provide a customer log message handler (callback function). More...
 
class  AnyError
 Error class interface. Allows the definition and use of a hierarchy of error classes which can all be handled in one catch block. Inherits from the standard exception base-class, to make life easier for library users (they have the option of catching most things via std::exception). More...
 
class  BasicError
 Simple error class used for exceptions. An output operator is provided to print errors to a stream. More...
 
class  Exifdatum
 An Exif metadatum, consisting of an ExifKey and a Value and methods to manipulate these. More...
 
class  ExifThumbC
 Access to a Exif thumbnail image. This class provides higher level accessors to the thumbnail image that is optionally embedded in IFD1 of the Exif data. These methods do not write to the Exif metadata. Manipulators are provided in subclass ExifThumb. More...
 
class  ExifThumb
 Access and modify an Exif thumbnail image. This class implements manipulators to set and erase the thumbnail image that is optionally embedded in IFD1 of the Exif data. Accessors are provided by the base class, ExifThumbC. More...
 
class  ExifData
 A container for Exif data. This is a top-level class of the Exiv2 library. The container holds Exifdatum objects. More...
 
class  ExifParser
 Stateless parser class for Exif data. Images use this class to decode and encode binary Exif data. More...
 
class  Uri
 A container for URL components. It also provides the method to parse a URL to get the protocol, host, path, port, querystring, username, password. More...
 
class  GifImage
 Class to access raw GIF images. Exif/IPTC metadata are supported directly. More...
 
struct  NativePreview
 Native preview information. This is meant to be used only by the PreviewManager. More...
 
class  Image
 Abstract base class defining the interface for an image. This is the top-level interface to the Exiv2 library. More...
 
class  ImageFactory
 Returns an Image instance of the specified type. More...
 
class  Iptcdatum
 An IPTC metadatum ("dataset"), consisting of an IptcKey and a Value and methods to manipulate these. More...
 
class  IptcData
 A container for IPTC data. This is a top-level class of the Exiv2 library. More...
 
class  IptcParser
 Stateless parser class for IPTC data. Images use this class to decode and encode binary IPTC data. More...
 
class  Jp2Image
 Class to access JPEG-2000 images. More...
 
struct  Photoshop
 Helper class, has methods to deal with Photoshop "Information Resource Blocks" (IRBs). More...
 
class  JpegBase
 Abstract helper base class to access JPEG images. More...
 
class  JpegImage
 Class to access JPEG images. More...
 
class  ExvImage
 Helper class to access Exiv2 files. More...
 
struct  MatroskaTags
 Helper structure for the Matroska tags lookup table. More...
 
class  MatroskaVideo
 Class to access Matroska video files. More...
 
class  Key
 Abstract base class defining the Key of a metadatum. Keys are used to identify and group metadata. More...
 
class  Metadatum
 Abstract base class defining the interface to access information related to one metadata tag. More...
 
class  MrwImage
 Class to access raw Minolta MRW images. Exif metadata is supported directly, IPTC is read from the Exif data, if present. More...
 
class  OrfImage
 Class to access raw Olympus ORF images. Exif metadata is supported directly, IPTC is read from the Exif data, if present. More...
 
class  OrfParser
 Stateless parser class for data in ORF format. Images use this class to decode and encode ORF data. See class TiffParser for details. More...
 
class  PgfImage
 Class to access PGF images. Exif and IPTC metadata are supported directly. More...
 
class  PngImage
 Class to access PNG images. Exif and IPTC metadata are supported directly. More...
 
struct  PreviewProperties
 Preview image properties. More...
 
class  PreviewImage
 Class that holds preview image properties and data buffer. More...
 
class  PreviewManager
 Class for extracting preview images from image metadata. More...
 
struct  XmpPropertyInfo
 Information about one XMP property. More...
 
struct  XmpNsInfo
 Structure mapping XMP namespaces and (preferred) prefixes. More...
 
class  XmpProperties
 XMP property reference, implemented as a static class. More...
 
class  XmpKey
 Concrete keys for XMP metadata. More...
 
class  PsdImage
 Class to access raw Photoshop images. More...
 
class  QuickTimeVideo
 Class to access QuickTime video files. More...
 
class  RafImage
 Class to access raw Fujifilm RAF images. Exif metadata is supported directly, IPTC is read from the Exif data, if present. More...
 
class  RiffVideo
 Class to access RIFF video files. More...
 
class  Rw2Image
 Class to access raw Panasonic RW2 images. Exif metadata is supported directly, IPTC and XMP are read from the Exif data, if present. More...
 
class  Rw2Parser
 Stateless parser class for data in RW2 format. Images use this class to decode and encode RW2 data. Only decoding is currently implemented. See class TiffParser for details. More...
 
struct  GroupInfo
 The details of an Exif group. Groups include IFDs and binary arrays. More...
 
struct  TagInfo
 Tag information. More...
 
class  ExifTags
 Access to Exif group and tag lists and misc. tag reference methods, implemented as a static class. More...
 
class  ExifKey
 Concrete keys for Exif metadata and access to Exif tag reference data. More...
 
class  TgaImage
 Class to access raw TARGA images. This is just a stub - we only read width and height. More...
 
class  TiffImage
 Class to access TIFF images. Exif metadata is supported directly, IPTC is read from the Exif data, if present. More...
 
class  TiffParser
 Stateless parser class for data in TIFF format. Images use this class to decode and encode TIFF data. It is a wrapper of the internal class Internal::TiffParserWorker. More...
 
class  TypeInfo
 Type information lookup functions. Implemented as a static class. More...
 
struct  DataBufRef
 Auxiliary type to enable copies and assignments, similar to std::auto_ptr_ref. See http://www.josuttis.com/libbook/auto_ptr.html for a discussion. More...
 
class  DataBuf
 Utility class containing a character array. All it does is to take care of memory allocation and deletion. Its primary use is meant to be as a stack variable in functions that need a temporary data buffer. More...
 
class  UtilsVideo
 
class  Value
 Common interface for all types of values used with metadata. More...
 
class  DataValue
 Value for an undefined data type. More...
 
class  StringValueBase
 Abstract base class for a string based Value type. More...
 
class  StringValue
 Value for string type. More...
 
class  AsciiValue
 Value for an Ascii string type. More...
 
class  CommentValue
 Value for an Exif comment. More...
 
class  XmpValue
 Base class for all Exiv2 values used to store XMP property values. More...
 
class  XmpTextValue
 Value type suitable for simple XMP properties and XMP nodes of complex types which are not parsed into specific values. More...
 
class  XmpArrayValue
 Value type for simple arrays. Each item in the array is a simple value, without qualifiers. The array may be an ordered (seq), unordered (bag) or alternative array (alt). The array items must not contain qualifiers. For language alternatives use LangAltValue. More...
 
struct  LangAltValueComparator
 LangAltValueComparator More...
 
class  LangAltValue
 Value type for XMP language alternative properties. More...
 
class  DateValue
 Value for simple ISO 8601 dates More...
 
class  TimeValue
 Value for simple ISO 8601 times. More...
 
class  ValueType
 Template for a Value of a basic type. This is used for unsigned and signed short, long and rationals. More...
 
class  Xmpdatum
 Information related to an XMP property. An XMP metadatum consists of an XmpKey and a Value and provides methods to manipulate these. More...
 
class  XmpData
 A container for XMP data. This is a top-level class of the Exiv2 library. More...
 
class  XmpParser
 Stateless parser class for XMP packets. Images use this class to parse and serialize XMP packets. The parser uses the XMP toolkit to do the job. More...
 
class  XmpSidecar
 Class to access XMP sidecar files. They contain only XMP metadata. More...
 

Typedefs

typedef BasicError< char > Error
 Error class used for exceptions (std::string based)
 
typedef std::list< ExifdatumExifMetadata
 Container type to hold all metadata.
 
typedef std::map< std::string,
std::string > 
dict_t
 
typedef dict_t::iterator dict_i
 
typedef std::vector
< NativePreview
NativePreviewList
 List of native previews. This is meant to be used only by the PreviewManager.
 
typedef Image::AutoPtr(* NewInstanceFct )(BasicIo::AutoPtr io, bool create)
 Type for function pointer that creates new Image instances.
 
typedef bool(* IsThisTypeFct )(BasicIo &iIo, bool advance)
 Type for function pointer that checks image types.
 
typedef std::vector< IptcdatumIptcMetadata
 Container type to hold all metadata.
 
typedef int PreviewId
 Type of preview image.
 
typedef std::vector
< PreviewProperties
PreviewPropertiesList
 Container type to hold all preview images metadata.
 
typedef std::ostream &(* PrintFct )(std::ostream &, const Value &, const ExifData *pExifData)
 Type for a function pointer for functions interpreting the tag value.
 
typedef const TagInfo *(* TagListFct )()
 A function returning a tag list.
 
typedef uint8_t byte
 1 byte unsigned integer type.
 
typedef std::pair< uint32_t,
uint32_t > 
URational
 8 byte unsigned rational type.
 
typedef std::pair< int32_t,
int32_t > 
Rational
 8 byte signed rational type.
 
typedef std::vector< byteBlob
 Container for binary data.
 
typedef ValueType< uint16_t > UShortValue
 Unsigned short value type.
 
typedef ValueType< uint32_t > ULongValue
 Unsigned long value type.
 
typedef ValueType< URationalURationalValue
 Unsigned rational value type.
 
typedef ValueType< int16_t > ShortValue
 Signed short value type.
 
typedef ValueType< int32_t > LongValue
 Signed long value type.
 
typedef ValueType< RationalRationalValue
 Signed rational value type.
 
typedef ValueType< float > FloatValue
 Float value type.
 
typedef ValueType< double > DoubleValue
 Double value type.
 
typedef std::vector< XmpdatumXmpMetadata
 Container type to hold all metadata.
 

Enumerations

enum  EnVar { envHTTPPOST = 0, envTIMEOUT = 1 }
 the name of environmental variables.
 
enum  Protocol {
  pFile = 0, pHttp, pFtp, pHttps,
  pSftp, pSsh, pFileUri, pDataUri,
  pStdin
}
 the collection of protocols.
 
enum  PrintStructureOption { kpsNone, kpsBasic, kpsXMP }
 Options for printStructure.
 
enum  XmpCategory { xmpInternal, xmpExternal }
 Category of an XMP property.
 
enum  ByteOrder { invalidByteOrder, littleEndian, bigEndian }
 Type to express the byte order (little or big endian)
 
enum  WriteMethod { wmIntrusive, wmNonIntrusive }
 Type to indicate write method used by TIFF parsers.
 
enum  MetadataId {
  mdNone =0, mdExif =1, mdIptc =2, mdComment =4,
  mdXmp =8
}
 An identifier for each type of metadata.
 
enum  AccessMode { amNone =0, amRead =1, amWrite =2, amReadWrite =3 }
 An identifier for each mode of metadata support.
 
enum  TypeId {
  unsignedByte = 1, asciiString = 2, unsignedShort = 3, unsignedLong = 4,
  unsignedRational = 5, signedByte = 6, undefined = 7, signedShort = 8,
  signedLong = 9, signedRational =10, tiffFloat =11, tiffDouble =12,
  tiffIfd =13, string =0x10000, date =0x10001, time =0x10002,
  comment =0x10003, directory =0x10004, xmpText =0x10005, xmpAlt =0x10006,
  xmpBag =0x10007, xmpSeq =0x10008, langAlt =0x10009, invalidTypeId =0x1fffe,
  lastTypeId =0x1ffff
}
 Exiv2 value type identifiers. More...
 

Functions

EXIV2API Image::AutoPtr newAsfInstance (BasicIo::AutoPtr io, bool create)
 Create a new AsfVideo instance and return an auto-pointer to it. Caller owns the returned object and the auto-pointer ensures that it will be deleted.
 
EXIV2API bool isAsfType (BasicIo &iIo, bool advance)
 Check if the file iIo is a Windows Asf Video.
 
EXIV2API DataBuf readFile (const std::string &path)
 Read file path into a DataBuf, which is returned. More...
 
EXIV2API long writeFile (const DataBuf &buf, const std::string &path)
 Write DataBuf buf to file path. More...
 
EXIV2API std::string ReplaceStringInPlace (std::string subject, const std::string &search, const std::string &replace)
 replace each substring of the subject that matches the given search string with the given replacement. More...
 
EXIV2API Image::AutoPtr newBmpInstance (BasicIo::AutoPtr io, bool create)
 Create a new BmpImage instance and return an auto-pointer to it. Caller owns the returned object and the auto-pointer ensures that it will be deleted.
 
EXIV2API bool isBmpType (BasicIo &iIo, bool advance)
 Check if the file iIo is a Windows Bitmap image.
 
EXIV2API void copyExifToXmp (const ExifData &exifData, XmpData &xmpData)
 Convert (copy) Exif tags to XMP properties.
 
EXIV2API void moveExifToXmp (ExifData &exifData, XmpData &xmpData)
 Convert (move) Exif tags to XMP properties, remove converted Exif tags.
 
EXIV2API void copyXmpToExif (const XmpData &xmpData, ExifData &exifData)
 Convert (copy) XMP properties to Exif tags.
 
EXIV2API void moveXmpToExif (XmpData &xmpData, ExifData &exifData)
 Convert (move) XMP properties to Exif tags, remove converted XMP properties.
 
EXIV2API void syncExifWithXmp (ExifData &exifData, XmpData &xmpData)
 Detect which metadata are newer and perform a copy in appropriate direction.
 
EXIV2API void copyIptcToXmp (const IptcData &iptcData, XmpData &xmpData, const char *iptcCharset=0)
 Convert (copy) IPTC datasets to XMP properties.
 
EXIV2API void moveIptcToXmp (IptcData &iptcData, XmpData &xmpData, const char *iptcCharset=0)
 Convert (move) IPTC datasets to XMP properties, remove converted IPTC datasets.
 
EXIV2API void copyXmpToIptc (const XmpData &xmpData, IptcData &iptcData)
 Convert (copy) XMP properties to IPTC datasets.
 
EXIV2API void moveXmpToIptc (XmpData &xmpData, IptcData &iptcData)
 Convert (move) XMP properties to IPTC tags, remove converted XMP properties.
 
EXIV2API bool convertStringCharset (std::string &str, const char *from, const char *to)
 Convert character encoding of str from from to to. If the function succeeds, str contains the result string. More...
 
EXIV2API Image::AutoPtr newCr2Instance (BasicIo::AutoPtr io, bool create)
 Create a new Cr2Image instance and return an auto-pointer to it. Caller owns the returned object and the auto-pointer ensures that it will be deleted.
 
EXIV2API bool isCr2Type (BasicIo &iIo, bool advance)
 Check if the file iIo is a CR2 image.
 
EXIV2API Image::AutoPtr newCrwInstance (BasicIo::AutoPtr io, bool create)
 Create a new CrwImage instance and return an auto-pointer to it. Caller owns the returned object and the auto-pointer ensures that it will be deleted.
 
EXIV2API bool isCrwType (BasicIo &iIo, bool advance)
 Check if the file iIo is a CRW image.
 
EXIV2API std::ostream & operator<< (std::ostream &os, const DataSet &dataSet)
 Output operator for dataSet.
 
EXIV2API ExifData::const_iterator orientation (const ExifData &ed)
 Return the orientation of the image.
 
EXIV2API ExifData::const_iterator isoSpeed (const ExifData &ed)
 Return the ISO speed used to shoot the image.
 
EXIV2API ExifData::const_iterator flashBias (const ExifData &ed)
 Return the flash bias value.
 
EXIV2API ExifData::const_iterator exposureMode (const ExifData &ed)
 Return the exposure mode setting.
 
EXIV2API ExifData::const_iterator sceneMode (const ExifData &ed)
 Return the scene mode setting.
 
EXIV2API ExifData::const_iterator macroMode (const ExifData &ed)
 Return the macro mode setting.
 
EXIV2API ExifData::const_iterator imageQuality (const ExifData &ed)
 Return the image quality setting.
 
EXIV2API ExifData::const_iterator whiteBalance (const ExifData &ed)
 Return the white balance setting.
 
EXIV2API ExifData::const_iterator lensName (const ExifData &ed)
 Return the name of the lens used.
 
EXIV2API ExifData::const_iterator saturation (const ExifData &ed)
 Return the saturation level.
 
EXIV2API ExifData::const_iterator sharpness (const ExifData &ed)
 Return the sharpness level.
 
EXIV2API ExifData::const_iterator contrast (const ExifData &ed)
 Return the contrast level.
 
EXIV2API ExifData::const_iterator sceneCaptureType (const ExifData &ed)
 Return the scene capture type.
 
EXIV2API ExifData::const_iterator meteringMode (const ExifData &ed)
 Return the metering mode setting.
 
EXIV2API ExifData::const_iterator make (const ExifData &ed)
 Return the camera make.
 
EXIV2API ExifData::const_iterator model (const ExifData &ed)
 Return the camera model.
 
EXIV2API ExifData::const_iterator exposureTime (const ExifData &ed)
 Return the exposure time.
 
EXIV2API ExifData::const_iterator fNumber (const ExifData &ed)
 Return the F number.
 
EXIV2API ExifData::const_iterator subjectDistance (const ExifData &ed)
 Return the subject distance.
 
EXIV2API ExifData::const_iterator serialNumber (const ExifData &ed)
 Return the camera serial number.
 
EXIV2API ExifData::const_iterator focalLength (const ExifData &ed)
 Return the focal length setting.
 
EXIV2API ExifData::const_iterator afPoint (const ExifData &ed)
 Return the AF point.
 
EXIV2API Image::AutoPtr newEpsInstance (BasicIo::AutoPtr io, bool create)
 Create a new EpsImage instance and return an auto-pointer to it. Caller owns the returned object and the auto-pointer ensures that it will be deleted.
 
EXIV2API bool isEpsType (BasicIo &iIo, bool advance)
 Check if the file iIo is a EPS image.
 
template<typename charT , typename T >
std::basic_string< charT > toBasicString (const T &arg)
 Generalised toString function.
 
std::ostream & operator<< (std::ostream &os, const AnyError &error)
 AnyError output operator
 
EXIV2API const char * errMsg (int code)
 Return the error message for the error with code code.
 
EXIV2API std::string getEnv (EnVar var)
 Return the value of environmental variable. More...
 
EXIV2API char to_hex (char code)
 Convert an integer value to its hex character. More...
 
EXIV2API char from_hex (char ch)
 Convert a hex character to its integer value. More...
 
EXIV2API char * urlencode (char *str)
 Encode the input url. More...
 
EXIV2API char * urldecode (const char *str)
 Decode the input url. More...
 
EXIV2API void urldecode (std::string &str)
 Like urlencode(char* str) but accept the input url in the std::string and modify it.
 
EXIV2API int base64encode (const void *data_buf, size_t dataLength, char *result, size_t resultSize)
 Encode in base64 the data in data_buf and put the resulting string in result. More...
 
EXIV2API long base64decode (const char *in, char *out, size_t out_size)
 Decode base64 data and put the resulting string in out. More...
 
EXIV2API Protocol fileProtocol (const std::string &path)
 Return the protocol of the path. More...
 
EXIV2API bool fileExists (const std::string &path, bool ct=false)
 Test if a file exists. More...
 
EXIV2API std::string pathOfFileUrl (const std::string &url)
 Get the path of file URL. More...
 
EXIV2API std::string strError ()
 Return a system error message and the error code (errno). See strerror(3).
 
EXIV2API Image::AutoPtr newGifInstance (BasicIo::AutoPtr io, bool create)
 Create a new GifImage instance and return an auto-pointer to it. Caller owns the returned object and the auto-pointer ensures that it will be deleted.
 
EXIV2API bool isGifType (BasicIo &iIo, bool advance)
 Check if the file iIo is a GIF image.
 
EXIV2API int http (dict_t &request, dict_t &response, std::string &errors)
 
void append (Exiv2::Blob &blob, const byte *buf, uint32_t len)
 Append len bytes pointed to by buf to blob.
 
EXIV2API Image::AutoPtr newJp2Instance (BasicIo::AutoPtr io, bool create)
 Create a new Jp2Image instance and return an auto-pointer to it. Caller owns the returned object and the auto-pointer ensures that it will be deleted.
 
EXIV2API bool isJp2Type (BasicIo &iIo, bool advance)
 Check if the file iIo is a JPEG-2000 image.
 
EXIV2API Image::AutoPtr newJpegInstance (BasicIo::AutoPtr io, bool create)
 Create a new JpegImage instance and return an auto-pointer to it. Caller owns the returned object and the auto-pointer ensures that it will be deleted.
 
EXIV2API bool isJpegType (BasicIo &iIo, bool advance)
 Check if the file iIo is a JPEG image.
 
EXIV2API Image::AutoPtr newExvInstance (BasicIo::AutoPtr io, bool create)
 Create a new ExvImage instance and return an auto-pointer to it. Caller owns the returned object and the auto-pointer ensures that it will be deleted.
 
EXIV2API bool isExvType (BasicIo &iIo, bool advance)
 Check if the file iIo is an EXV file.
 
EXIV2API Image::AutoPtr newMkvInstance (BasicIo::AutoPtr io, bool create)
 Create a new MatroskaVideo instance and return an auto-pointer to it. Caller owns the returned object and the auto-pointer ensures that it will be deleted.
 
EXIV2API bool isMkvType (BasicIo &iIo, bool advance)
 Check if the file iIo is a Matroska Video.
 
std::ostream & operator<< (std::ostream &os, const Key &key)
 Output operator for Key types.
 
std::ostream & operator<< (std::ostream &os, const Metadatum &md)
 Output operator for Metadatum types, writing the interpreted tag value.
 
EXIV2API bool cmpMetadataByTag (const Metadatum &lhs, const Metadatum &rhs)
 Compare two metadata by tag. Return true if the tag of metadatum lhs is less than that of rhs.
 
EXIV2API bool cmpMetadataByKey (const Metadatum &lhs, const Metadatum &rhs)
 Compare two metadata by key. Return true if the key of metadatum lhs is less than that of rhs.
 
EXIV2API Image::AutoPtr newMrwInstance (BasicIo::AutoPtr io, bool create)
 Create a new MrwImage instance and return an auto-pointer to it. Caller owns the returned object and the auto-pointer ensures that it will be deleted.
 
EXIV2API bool isMrwType (BasicIo &iIo, bool advance)
 Check if the file iIo is a MRW image.
 
EXIV2API Image::AutoPtr newOrfInstance (BasicIo::AutoPtr io, bool create)
 Create a new OrfImage instance and return an auto-pointer to it. Caller owns the returned object and the auto-pointer ensures that it will be deleted.
 
EXIV2API bool isOrfType (BasicIo &iIo, bool advance)
 Check if the file iIo is an ORF image.
 
EXIV2API Image::AutoPtr newPgfInstance (BasicIo::AutoPtr io, bool create)
 Create a new PgfImage instance and return an auto-pointer to it. Caller owns the returned object and the auto-pointer ensures that it will be deleted.
 
EXIV2API bool isPgfType (BasicIo &iIo, bool advance)
 Check if the file iIo is a PGF image.
 
EXIV2API Image::AutoPtr newPngInstance (BasicIo::AutoPtr io, bool create)
 Create a new PngImage instance and return an auto-pointer to it. Caller owns the returned object and the auto-pointer ensures that it will be deleted.
 
EXIV2API bool isPngType (BasicIo &iIo, bool advance)
 Check if the file iIo is a PNG image.
 
EXIV2API std::ostream & operator<< (std::ostream &os, const XmpPropertyInfo &propertyInfo)
 Output operator for property info.
 
EXIV2API Image::AutoPtr newPsdInstance (BasicIo::AutoPtr io, bool create)
 Create a new PsdImage instance and return an auto-pointer to it. Caller owns the returned object and the auto-pointer ensures that it will be deleted.
 
EXIV2API bool isPsdType (BasicIo &iIo, bool advance)
 Check if the file iIo is a Photoshop image.
 
EXIV2API Image::AutoPtr newQTimeInstance (BasicIo::AutoPtr io, bool create)
 Create a new QuicktimeVideo instance and return an auto-pointer to it. Caller owns the returned object and the auto-pointer ensures that it will be deleted.
 
EXIV2API bool isQTimeType (BasicIo &iIo, bool advance)
 Check if the file iIo is a Quick Time Video.
 
EXIV2API Image::AutoPtr newRafInstance (BasicIo::AutoPtr io, bool create)
 Create a new RafImage instance and return an auto-pointer to it. Caller owns the returned object and the auto-pointer ensures that it will be deleted.
 
EXIV2API bool isRafType (BasicIo &iIo, bool advance)
 Check if the file iIo is a RAF image.
 
EXIV2API Image::AutoPtr newRiffInstance (BasicIo::AutoPtr io, bool create)
 Create a new RiffVideo instance and return an auto-pointer to it. Caller owns the returned object and the auto-pointer ensures that it will be deleted.
 
EXIV2API bool isRiffType (BasicIo &iIo, bool advance)
 Check if the file iIo is a Riff Video.
 
EXIV2API Image::AutoPtr newRw2Instance (BasicIo::AutoPtr io, bool create)
 Create a new Rw2Image instance and return an auto-pointer to it. Caller owns the returned object and the auto-pointer ensures that it will be deleted.
 
EXIV2API bool isRw2Type (BasicIo &iIo, bool advance)
 Check if the file iIo is a RW2 image.
 
EXIV2API std::ostream & operator<< (std::ostream &os, const TagInfo &ti)
 Output operator for TagInfo.
 
EXIV2API Image::AutoPtr newTgaInstance (BasicIo::AutoPtr io, bool create)
 Create a new TgaImage instance and return an auto-pointer to it. Caller owns the returned object and the auto-pointer ensures that it will be deleted.
 
EXIV2API bool isTgaType (BasicIo &iIo, bool advance)
 Check if the file iIo is a Targa v2 image.
 
EXIV2API Image::AutoPtr newTiffInstance (BasicIo::AutoPtr io, bool create)
 Create a new TiffImage instance and return an auto-pointer to it. Caller owns the returned object and the auto-pointer ensures that it will be deleted.
 
EXIV2API bool isTiffType (BasicIo &iIo, bool advance)
 Check if the file iIo is a TIFF image.
 
EXIV2API uint16_t getUShort (const byte *buf, ByteOrder byteOrder)
 Read a 2 byte unsigned short value from the data buffer.
 
EXIV2API uint32_t getULong (const byte *buf, ByteOrder byteOrder)
 Read a 4 byte unsigned long value from the data buffer.
 
EXIV2API URational getURational (const byte *buf, ByteOrder byteOrder)
 Read an 8 byte unsigned rational value from the data buffer.
 
EXIV2API int16_t getShort (const byte *buf, ByteOrder byteOrder)
 Read a 2 byte signed short value from the data buffer.
 
EXIV2API int32_t getLong (const byte *buf, ByteOrder byteOrder)
 Read a 4 byte signed long value from the data buffer.
 
EXIV2API Rational getRational (const byte *buf, ByteOrder byteOrder)
 Read an 8 byte signed rational value from the data buffer.
 
EXIV2API float getFloat (const byte *buf, ByteOrder byteOrder)
 Read a 4 byte single precision floating point value (IEEE 754 binary32) from the data buffer.
 
EXIV2API double getDouble (const byte *buf, ByteOrder byteOrder)
 Read an 8 byte double precision floating point value (IEEE 754 binary64) from the data buffer.
 
EXIV2API std::ostream & operator<< (std::ostream &os, const Rational &r)
 Output operator for our fake rational.
 
EXIV2API std::istream & operator>> (std::istream &is, Rational &r)
 Input operator for our fake rational.
 
EXIV2API std::ostream & operator<< (std::ostream &os, const URational &r)
 Output operator for our fake unsigned rational.
 
EXIV2API std::istream & operator>> (std::istream &is, URational &r)
 Input operator for our fake unsigned rational.
 
EXIV2API long us2Data (byte *buf, uint16_t s, ByteOrder byteOrder)
 Convert an unsigned short to data, write the data to the buffer, return number of bytes written.
 
EXIV2API long ul2Data (byte *buf, uint32_t l, ByteOrder byteOrder)
 Convert an unsigned long to data, write the data to the buffer, return number of bytes written.
 
EXIV2API long ur2Data (byte *buf, URational l, ByteOrder byteOrder)
 Convert an unsigned rational to data, write the data to the buffer, return number of bytes written.
 
EXIV2API long s2Data (byte *buf, int16_t s, ByteOrder byteOrder)
 Convert a signed short to data, write the data to the buffer, return number of bytes written.
 
EXIV2API long l2Data (byte *buf, int32_t l, ByteOrder byteOrder)
 Convert a signed long to data, write the data to the buffer, return number of bytes written.
 
EXIV2API long r2Data (byte *buf, Rational l, ByteOrder byteOrder)
 Convert a signed rational to data, write the data to the buffer, return number of bytes written.
 
EXIV2API long f2Data (byte *buf, float f, ByteOrder byteOrder)
 Convert a single precision floating point (IEEE 754 binary32) float to data, write the data to the buffer, return number of bytes written.
 
EXIV2API long d2Data (byte *buf, double d, ByteOrder byteOrder)
 Convert a double precision floating point (IEEE 754 binary64) double to data, write the data to the buffer, return number of bytes written.
 
EXIV2API void hexdump (std::ostream &os, const byte *buf, long len, long offset=0)
 Print len bytes from buf in hex and ASCII format to the given stream, prefixed with the position in the buffer adjusted by offset.
 
EXIV2API bool isHex (const std::string &str, size_t size=0, const std::string &prefix="")
 Return true if str is a hex number starting with prefix followed by size hex digits, false otherwise. If size is 0, any number of digits is allowed and all are checked.
 
EXIV2API int exifTime (const char *buf, struct tm *tm)
 Converts a string in the form "%Y:%m:%d %H:%M:%S", e.g., "2007:05:24 12:31:55" to broken down time format, returns 0 if successful, else 1.
 
EXIV2API const char * exvGettext (const char *str)
 Translate a string using the gettext framework. This wrapper hides all the implementation details from the interface.
 
EXIV2API long parseLong (const std::string &s, bool &ok)
 Return a long set to the value represented by s. More...
 
EXIV2API float parseFloat (const std::string &s, bool &ok)
 Return a float set to the value represented by s. More...
 
EXIV2API Rational parseRational (const std::string &s, bool &ok)
 Return a Rational set to the value represented by s. More...
 
EXIV2API Rational floatToRationalCast (float f)
 Very simple conversion of a float to a Rational. More...
 
template<typename T , typename K , int N>
const T * find (T(&src)[N], const K &key)
 Find an element that matches key in the array src. More...
 
template<typename T , int N>
char(& sizer (T(&)[N]))[N]
 Template used in the COUNTOF macro to determine the size of an array.
 
template<typename T >
std::string toString (const T &arg)
 Utility function to convert the argument of any type to a string.
 
template<typename T >
stringTo (const std::string &s, bool &ok)
 Utility function to convert a string to a value of type T. More...
 
template<>
bool stringTo< bool > (const std::string &s, bool &ok)
 Specialization of stringTo(const std::string& s, bool& ok) for bool. More...
 
template<typename IntType >
IntType gcd (IntType n, IntType m)
 Return the greatest common denominator of n and m. (Implementation from Boost rational.hpp) More...
 
std::ostream & operator<< (std::ostream &os, const Value &value)
 Output operator for Value types.
 
template<typename T >
TypeId getType ()
 Template to determine the TypeId for a type T.
 
template<>
TypeId getType< uint16_t > ()
 Specialization for an unsigned short.
 
template<>
TypeId getType< uint32_t > ()
 Specialization for an unsigned long.
 
template<>
TypeId getType< URational > ()
 Specialization for an unsigned rational.
 
template<>
TypeId getType< int16_t > ()
 Specialization for a signed short.
 
template<>
TypeId getType< int32_t > ()
 Specialization for a signed long.
 
template<>
TypeId getType< Rational > ()
 Specialization for a signed rational.
 
template<>
TypeId getType< float > ()
 Specialization for a float.
 
template<>
TypeId getType< double > ()
 Specialization for a double.
 
template<typename T >
getValue (const byte *buf, ByteOrder byteOrder)
 Read a value of type T from the data buffer. More...
 
template<>
uint16_t getValue (const byte *buf, ByteOrder byteOrder)
 Read a value of type T from the data buffer. More...
 
template<>
uint32_t getValue (const byte *buf, ByteOrder byteOrder)
 Read a value of type T from the data buffer. More...
 
template<>
URational getValue (const byte *buf, ByteOrder byteOrder)
 Read a value of type T from the data buffer. More...
 
template<>
int16_t getValue (const byte *buf, ByteOrder byteOrder)
 Read a value of type T from the data buffer. More...
 
template<>
int32_t getValue (const byte *buf, ByteOrder byteOrder)
 Read a value of type T from the data buffer. More...
 
template<>
Rational getValue (const byte *buf, ByteOrder byteOrder)
 Read a value of type T from the data buffer. More...
 
template<>
float getValue (const byte *buf, ByteOrder byteOrder)
 Read a value of type T from the data buffer. More...
 
template<>
double getValue (const byte *buf, ByteOrder byteOrder)
 Read a value of type T from the data buffer. More...
 
template<typename T >
long toData (byte *buf, T t, ByteOrder byteOrder)
 Convert a value of type T to data, write the data to the data buffer. More...
 
template<>
long toData (byte *buf, uint16_t t, ByteOrder byteOrder)
 Specialization to write an unsigned short to the data buffer. Return the number of bytes written.
 
template<>
long toData (byte *buf, uint32_t t, ByteOrder byteOrder)
 Specialization to write an unsigned long to the data buffer. Return the number of bytes written.
 
template<>
long toData (byte *buf, URational t, ByteOrder byteOrder)
 Specialization to write an unsigned rational to the data buffer. Return the number of bytes written.
 
template<>
long toData (byte *buf, int16_t t, ByteOrder byteOrder)
 Specialization to write a signed short to the data buffer. Return the number of bytes written.
 
template<>
long toData (byte *buf, int32_t t, ByteOrder byteOrder)
 Specialization to write a signed long to the data buffer. Return the number of bytes written.
 
template<>
long toData (byte *buf, Rational t, ByteOrder byteOrder)
 Specialization to write a signed rational to the data buffer. Return the number of bytes written.
 
template<>
long toData (byte *buf, float t, ByteOrder byteOrder)
 Specialization to write a float to the data buffer. Return the number of bytes written.
 
template<>
long toData (byte *buf, double t, ByteOrder byteOrder)
 Specialization to write a double to the data buffer. Return the number of bytes written.
 
EXIV2API int versionNumber ()
 Return the version of Exiv2 available at runtime as an integer.
 
EXIV2API std::string versionString ()
 Return the version string Example: "0.25.0" (major.minor.patch)
 
EXIV2API std::string versionNumberHexString ()
 Return the version of Exiv2 as hex string of fixed length 6.
 
EXIV2API const char * version ()
 Return the version of Exiv2 available at runtime as a string.
 
EXIV2API bool testVersion (int major, int minor, int patch)
 Test the version of the available Exiv2 library at runtime. Return true if it is the same as or newer than the passed-in version. More...
 
EXIV2API void dumpLibraryInfo (std::ostream &os, const exv_grep_keys_t &keys)
 dumpLibraryInfo implements the exiv2 option –version –verbose used by exiv2 test suite to inspect libraries loaded at run-time
 
EXIV2API Image::AutoPtr newXmpInstance (BasicIo::AutoPtr io, bool create)
 Create a new XmpSidecar instance and return an auto-pointer to it. Caller owns the returned object and the auto-pointer ensures that it will be deleted.
 
EXIV2API bool isXmpType (BasicIo &iIo, bool advance)
 Check if the file iIo is an XMP sidecar file.
 

Detailed Description

Provides classes and functions to encode and decode Exif and Iptc data. The libexiv2 API consists of the objects of this namespace.

Enumeration Type Documentation

Exiv2 value type identifiers.

Used primarily as identifiers when creating Exiv2 Value instances. See Value::create. 0x0000 to 0xffff are reserved for TIFF (Exif) types.

Enumerator
unsignedByte 

Exif BYTE type, 8-bit unsigned integer.

asciiString 

Exif ASCII type, 8-bit byte.

unsignedShort 

Exif SHORT type, 16-bit (2-byte) unsigned integer.

unsignedLong 

Exif LONG type, 32-bit (4-byte) unsigned integer.

unsignedRational 

Exif RATIONAL type, two LONGs: numerator and denumerator of a fraction.

signedByte 

Exif SBYTE type, an 8-bit signed (twos-complement) integer.

undefined 

Exif UNDEFINED type, an 8-bit byte that may contain anything.

signedShort 

Exif SSHORT type, a 16-bit (2-byte) signed (twos-complement) integer.

signedLong 

Exif SLONG type, a 32-bit (4-byte) signed (twos-complement) integer.

signedRational 

Exif SRATIONAL type, two SLONGs: numerator and denumerator of a fraction.

tiffFloat 

TIFF FLOAT type, single precision (4-byte) IEEE format.

tiffDouble 

TIFF DOUBLE type, double precision (8-byte) IEEE format.

tiffIfd 

TIFF IFD type, 32-bit (4-byte) unsigned integer.

string 

IPTC string type.

date 

IPTC date type.

time 

IPTC time type.

comment 

Exiv2 type for the Exif user comment.

directory 

Exiv2 type for a CIFF directory.

xmpText 

XMP text type.

xmpAlt 

XMP alternative type.

xmpBag 

XMP bag type.

xmpSeq 

XMP sequence type.

langAlt 

XMP language alternative type.

invalidTypeId 

Invalid type id.

lastTypeId 

Last type id.

Function Documentation

EXIV2API long Exiv2::base64decode ( const char *  in,
char *  out,
size_t  out_size 
)

Decode base64 data and put the resulting string in out.

Parameters
inThe data need to decode.
outThe container for the result, it should be large enough to contain the result.
out_sizeThe size of out in bytes.
Returns
the size of the resulting string. If it fails, return -1.
Note
Source: https://github.com/davidgaleano/libwebsockets/blob/master/lib/base64-decode.c
EXIV2API int Exiv2::base64encode ( const void *  data_buf,
size_t  dataLength,
char *  result,
size_t  resultSize 
)

Encode in base64 the data in data_buf and put the resulting string in result.

Parameters
data_bufThe data need to encode
dataLengthSize in bytes of the in buffer
resultThe container for the result, NULL if it fails
resultSizeSize in bytes of the out string, it should be at least ((dataLength + 2) / 3) * 4 + 1
Returns
1 indicate success
Note
Source: http://en.wikibooks.org/wiki/Algorithm_Implementation/Miscellaneous/Base64
EXIV2API bool Exiv2::convertStringCharset ( std::string &  str,
const char *  from,
const char *  to 
)

Convert character encoding of str from from to to. If the function succeeds, str contains the result string.

This function uses the iconv library, if the Exiv2 library was compiled with iconv support. Otherwise, on Windows, it uses Windows functions to support a limited number of conversions and fails with a warning if an unsupported conversion is attempted. If the function is called but Exiv2 was not compiled with iconv support and can't use Windows functions, it fails with a warning.

The conversions supported on Windows without iconv are:

fromto
UTF-8 UCS-2BE
UTF-8 UCS-2LE
UCS-2BE UTF-8
UCS-2BE UCS-2LE
UCS-2LE UTF-8
UCS-2LE UCS-2BE
ISO-8859-1UTF-8
ASCII UTF-8
Parameters
strThe string to convert. It is updated to the converted string, which may have a different size. If the function call fails, the string is not modified.
fromCharset in which the input string is encoded as a name understood by iconv_open(3).
toCharset to convert the string to as a name understood by iconv_open(3).
Returns
Return true if the conversion was successful, else false.
EXIV2API bool Exiv2::fileExists ( const std::string &  path,
bool  ct = false 
)

Test if a file exists.

Parameters
pathName of file to verify.
ctFlag to check if path is a regular file.
Returns
true if path exists and, if ct is set, is a regular file, else false.
Note
The function calls stat() test for path and its type, see stat(2). errno is left unchanged in case of an error.
EXIV2API Protocol Exiv2::fileProtocol ( const std::string &  path)

Return the protocol of the path.

Parameters
pathThe path of file to extract the protocol.
Returns
the protocol of the path.
template<typename T , typename K , int N>
const T* Exiv2::find ( T(&)  src[N],
const K &  key 
)

Find an element that matches key in the array src.

Designed to be used with lookup tables as shown in the example below. Requires a Key structure (ideally in the array) and a comparison operator to compare a key with an array element. The size of the array is determined automagically. Thanks to Stephan Broennimann for this nifty implementation.

struct Bar {
int i;
int k;
const char* data;
struct Key;
bool operator==(const Bar::Key& rhs) const;
};
struct Bar::Key {
Key(int a, int b) : i(a), k(b) {}
int i;
int k;
};
bool Bar::operator==(const Bar::Key& key) const // definition
{
return i == key.i && k == key.k;
}
const Bar bars[] = {
{ 1, 1, "bar data 1" },
{ 1, 2, "bar data 2" },
{ 1, 3, "bar data 3" }
};
int main ( void ) {
const Bar* bar = find(bars, Bar::Key(1, 3));
if (bar) std::cout << bar->data << "\n";
else std::cout << "Key not found.\n";
return 0;
}
EXIV2API Rational Exiv2::floatToRationalCast ( float  f)

Very simple conversion of a float to a Rational.

Test it with the values that you expect and check the implementation to see if this is really what you want!

Referenced by Exiv2::ValueType< T >::toRational().

EXIV2API char Exiv2::from_hex ( char  ch)

Convert a hex character to its integer value.

Parameters
chThe hex character.
Returns
the input's integer value.
template<typename IntType >
IntType Exiv2::gcd ( IntType  n,
IntType  m 
)

Return the greatest common denominator of n and m. (Implementation from Boost rational.hpp)

Note
We use n and m as temporaries in this function, so there is no value in using const IntType& as we would only need to make a copy anyway...
EXIV2API std::string Exiv2::getEnv ( EnVar  var)

Return the value of environmental variable.

Parameters
varThe name of environmental variable.
Returns
the value of environmental variable. If it's empty, the default value is returned.
template<typename T >
T Exiv2::getValue ( const byte *  buf,
ByteOrder  byteOrder 
)
inline

Read a value of type T from the data buffer.

We need this template function for the ValueType template classes. There are only specializations of this function available; no default implementation is provided.

Parameters
bufPointer to the data buffer to read from.
byteOrderApplicable byte order (little or big endian).
Returns
A value of type T.

References getDouble(), getFloat(), getLong(), getRational(), getShort(), getULong(), getURational(), and getUShort().

template<>
uint16_t Exiv2::getValue ( const byte *  buf,
ByteOrder  byteOrder 
)
inline

Read a value of type T from the data buffer.

We need this template function for the ValueType template classes. There are only specializations of this function available; no default implementation is provided.

Parameters
bufPointer to the data buffer to read from.
byteOrderApplicable byte order (little or big endian).
Returns
A value of type T.

References getUShort().

template<>
uint32_t Exiv2::getValue ( const byte *  buf,
ByteOrder  byteOrder 
)
inline

Read a value of type T from the data buffer.

We need this template function for the ValueType template classes. There are only specializations of this function available; no default implementation is provided.

Parameters
bufPointer to the data buffer to read from.
byteOrderApplicable byte order (little or big endian).
Returns
A value of type T.

References getULong().

template<>
URational Exiv2::getValue ( const byte *  buf,
ByteOrder  byteOrder 
)
inline

Read a value of type T from the data buffer.

We need this template function for the ValueType template classes. There are only specializations of this function available; no default implementation is provided.

Parameters
bufPointer to the data buffer to read from.
byteOrderApplicable byte order (little or big endian).
Returns
A value of type T.

References getURational().

template<>
int16_t Exiv2::getValue ( const byte *  buf,
ByteOrder  byteOrder 
)
inline

Read a value of type T from the data buffer.

We need this template function for the ValueType template classes. There are only specializations of this function available; no default implementation is provided.

Parameters
bufPointer to the data buffer to read from.
byteOrderApplicable byte order (little or big endian).
Returns
A value of type T.

References getShort().

template<>
int32_t Exiv2::getValue ( const byte *  buf,
ByteOrder  byteOrder 
)
inline

Read a value of type T from the data buffer.

We need this template function for the ValueType template classes. There are only specializations of this function available; no default implementation is provided.

Parameters
bufPointer to the data buffer to read from.
byteOrderApplicable byte order (little or big endian).
Returns
A value of type T.

References getLong().

template<>
Rational Exiv2::getValue ( const byte *  buf,
ByteOrder  byteOrder 
)
inline

Read a value of type T from the data buffer.

We need this template function for the ValueType template classes. There are only specializations of this function available; no default implementation is provided.

Parameters
bufPointer to the data buffer to read from.
byteOrderApplicable byte order (little or big endian).
Returns
A value of type T.

References getRational().

template<>
float Exiv2::getValue ( const byte *  buf,
ByteOrder  byteOrder 
)
inline

Read a value of type T from the data buffer.

We need this template function for the ValueType template classes. There are only specializations of this function available; no default implementation is provided.

Parameters
bufPointer to the data buffer to read from.
byteOrderApplicable byte order (little or big endian).
Returns
A value of type T.

References getFloat().

template<>
double Exiv2::getValue ( const byte *  buf,
ByteOrder  byteOrder 
)
inline

Read a value of type T from the data buffer.

We need this template function for the ValueType template classes. There are only specializations of this function available; no default implementation is provided.

Parameters
bufPointer to the data buffer to read from.
byteOrderApplicable byte order (little or big endian).
Returns
A value of type T.

References getDouble().

EXIV2API float Exiv2::parseFloat ( const std::string &  s,
bool &  ok 
)

Return a float set to the value represented by s.

Besides strings that represent float values, the function also handles long, Rational and boolean (see also: stringTo(const std::string& s, bool& ok)).

Parameters
sString to parse
okOutput variable indicating the success of the operation.
Returns
Returns the float value represented by s and sets ok to true if the conversion was successful or false if not.
EXIV2API long Exiv2::parseLong ( const std::string &  s,
bool &  ok 
)

Return a long set to the value represented by s.

Besides strings that represent long values, the function also handles float, Rational and boolean (see also: stringTo(const std::string& s, bool& ok)).

Parameters
sString to parse
okOutput variable indicating the success of the operation.
Returns
Returns the long value represented by s and sets ok to true if the conversion was successful or false if not.
EXIV2API Rational Exiv2::parseRational ( const std::string &  s,
bool &  ok 
)

Return a Rational set to the value represented by s.

Besides strings that represent Rational values, the function also handles long, float and boolean (see also: stringTo(const std::string& s, bool& ok)). Uses floatToRationalCast(float f) if the string can be parsed into a float.

Parameters
sString to parse
okOutput variable indicating the success of the operation.
Returns
Returns the Rational value represented by s and sets ok to true if the conversion was successful or false if not.
EXIV2API std::string Exiv2::pathOfFileUrl ( const std::string &  url)

Get the path of file URL.

Parameters
urlThe file URL in the format file:///<path> or file://<host>/<path>.
Returns
the path of file URL.
EXIV2API DataBuf Exiv2::readFile ( const std::string &  path)

Read file path into a DataBuf, which is returned.

Returns
Buffer containing the file.
Exceptions
ErrorIn case of failure.
EXIV2API std::string Exiv2::ReplaceStringInPlace ( std::string  subject,
const std::string &  search,
const std::string &  replace 
)

replace each substring of the subject that matches the given search string with the given replacement.

Returns
the subject after replacing.
template<typename T >
T Exiv2::stringTo ( const std::string &  s,
bool &  ok 
)

Utility function to convert a string to a value of type T.

The string representation of the value must match that recognized by the input operator for T for this function to succeed.

Parameters
sString to convert
okOutput variable indicating the success of the operation.
Returns
Returns the converted value and sets ok to true if the conversion was successful or false if not.

References string.

template<>
bool Exiv2::stringTo< bool > ( const std::string &  s,
bool &  ok 
)

Specialization of stringTo(const std::string& s, bool& ok) for bool.

Handles the same string values as the XMP SDK. Converts the string to lowercase and returns true if it is "true", "t" or "1", and false if it is "false", "f" or "0".

EXIV2API bool Exiv2::testVersion ( int  major,
int  minor,
int  patch 
)

Test the version of the available Exiv2 library at runtime. Return true if it is the same as or newer than the passed-in version.

Versions are denoted using a triplet of integers: major.minor.patch .

// Don't include the <exiv2/version.hpp> file directly, it is included by
// <exiv2/types.hpp>. Early Exiv2 versions didn't have version.hpp and the macros.
#include <exiv2/types.hpp>
// Make sure an EXIV2_TEST_VERSION macro exists:
#ifdef EXIV2_VERSION
# ifndef EXIV2_TEST_VERSION
# define EXIV2_TEST_VERSION(major,minor,patch) \
( EXIV2_VERSION >= EXIV2_MAKE_VERSION(major,minor,patch) )
# endif
#else
# define EXIV2_TEST_VERSION(major,minor,patch) (false)
#endif
std::cout << "Compiled with Exiv2 version " << EXV_PACKAGE_VERSION << "\n"
<< "Runtime Exiv2 version is " << Exiv2::version() << "\n";
// Test the Exiv2 version available at runtime but compile the if-clause only if
// the compile-time version is at least 0.15. Earlier versions didn't have a
// testVersion() function:
#if EXIV2_TEST_VERSION(0,15,0)
if (Exiv2::testVersion(0,13,0)) {
std::cout << "Available Exiv2 version is equal to or greater than 0.13\n";
}
else {
std::cout << "Installed Exiv2 version is less than 0.13\n";
}
#else
std::cout << "Compile-time Exiv2 version doesn't have Exiv2::testVersion()\n";
#endif
EXIV2API char Exiv2::to_hex ( char  code)

Convert an integer value to its hex character.

Parameters
codeThe integer value.
Returns
the input's hex character.
template<typename T >
long Exiv2::toData ( byte *  buf,
t,
ByteOrder  byteOrder 
)

Convert a value of type T to data, write the data to the data buffer.

We need this template function for the ValueType template classes. There are only specializations of this function available; no default implementation is provided.

Parameters
bufPointer to the data buffer to write to.
tValue to be converted.
byteOrderApplicable byte order (little or big endian).
Returns
The number of bytes written to the buffer.

Referenced by Exiv2::ValueType< T >::copy().

EXIV2API char* Exiv2::urldecode ( const char *  str)

Decode the input url.

Parameters
strThe url needs decoding.
Returns
the url-decoded version of str.
Note
Be sure to free() the returned string after use Source: http://www.geekhideout.com/urlcode.shtml
EXIV2API char* Exiv2::urlencode ( char *  str)

Encode the input url.

Parameters
strThe url needs encoding.
Returns
the url-encoded version of str.
Note
Be sure to free() the returned string after use Source: http://www.geekhideout.com/urlcode.shtml
EXIV2API long Exiv2::writeFile ( const DataBuf &  buf,
const std::string &  path 
)

Write DataBuf buf to file path.

Returns
Return the number of bytes written.
Exceptions
ErrorIn case of failure.