tiffcomposite_int.hpp

// SPDX-License-Identifier: GPL-2.0-or-later
 
#ifndef TIFFCOMPOSITE_INT_HPP_
#define TIFFCOMPOSITE_INT_HPP_
 
// *****************************************************************************
// included header files
#include "tifffwd_int.hpp"
 
#include <memory>
 
// *****************************************************************************
// namespace extensions
namespace Exiv2 {
class BasicIo;
 
namespace Internal {
// *****************************************************************************
// class definitions
 
using TiffType = uint16_t;
 
const TiffType ttUnsignedByte = 1;      
const TiffType ttAsciiString = 2;       
const TiffType ttUnsignedShort = 3;     
const TiffType ttUnsignedLong = 4;      
const TiffType ttUnsignedRational = 5;  
const TiffType ttSignedByte = 6;        
const TiffType ttUndefined = 7;         
const TiffType ttSignedShort = 8;       
const TiffType ttSignedLong = 9;        
const TiffType ttSignedRational = 10;   
const TiffType ttTiffFloat = 11;        
const TiffType ttTiffDouble = 12;       
const TiffType ttTiffIfd = 13;          
 
TypeId toTypeId(TiffType tiffType, uint16_t tag, IfdId group);
TiffType toTiffType(TypeId typeId);
 
namespace Tag {
const uint32_t none = 0x10000;   
const uint32_t root = 0x20000;   
const uint32_t next = 0x30000;   
const uint32_t all = 0x40000;    
const uint32_t pana = 0x80000;   
const uint32_t fuji = 0x100000;  
const uint32_t cmt2 = 0x110000;  
const uint32_t cmt3 = 0x120000;  
const uint32_t cmt4 = 0x130000;  
}  // namespace Tag
 
class TiffPathItem {
 public:
 
 
  constexpr TiffPathItem(uint32_t extendedTag, IfdId group) : extendedTag_(extendedTag), group_(group) {
  }
 
 
 
  [[nodiscard]] uint16_t tag() const {
    return static_cast<uint16_t>(extendedTag_ & 0xffff);
  }
  [[nodiscard]] uint32_t extendedTag() const {
    return extendedTag_;
  }
  [[nodiscard]] IfdId group() const {
    return group_;
  }
 
 private:
  // DATA
  uint32_t extendedTag_;
  IfdId group_;
};
 
class IoWrapper {
 public:
 
 
  IoWrapper(BasicIo& io, const byte* pHeader, size_t size, OffsetWriter* pow);
 
 
 
  size_t write(const byte* pData, size_t wcount);
  int putb(byte data);
  void setTarget(int id, size_t target);
 
 private:
  // DATA
  BasicIo& io_;              
  const byte* pHeader_;      
  size_t size_;              
  bool wroteHeader_{false};  
  OffsetWriter* pow_;        
};
 
class TiffComponent {
 public:
  using UniquePtr = std::unique_ptr<TiffComponent>;
  using Components = std::vector<UniquePtr>;
 
 
 
  constexpr TiffComponent(uint16_t tag, IfdId group) : tag_(tag), group_(group) {
  }
  virtual ~TiffComponent() = default;
  TiffComponent(const TiffComponent&) = default;
  TiffComponent& operator=(const TiffComponent&) = default;
 
 
 
  TiffComponent* addPath(uint16_t tag, TiffPath& tiffPath, TiffComponent* pRoot, UniquePtr object = nullptr);
  TiffComponent* addChild(UniquePtr tiffComponent);
  TiffComponent* addNext(UniquePtr tiffComponent);
  void accept(TiffVisitor& visitor);
  void setStart(const byte* pStart) {
    pStart_ = const_cast<byte*>(pStart);
  }
  size_t write(IoWrapper& ioWrapper, ByteOrder byteOrder, size_t offset, size_t valueIdx, size_t dataIdx,
               size_t& imageIdx);
 
 
 
  [[nodiscard]] uint16_t tag() const {
    return tag_;
  }
  [[nodiscard]] IfdId group() const {
    return group_;
  }
  [[nodiscard]] byte* start() const {
    return pStart_;
  }
  [[nodiscard]] UniquePtr clone() const;
  size_t writeData(IoWrapper& ioWrapper, ByteOrder byteOrder, size_t offset, size_t dataIdx, size_t& imageIdx) const;
  size_t writeImage(IoWrapper& ioWrapper, ByteOrder byteOrder) const;
  [[nodiscard]] size_t size() const;
  [[nodiscard]] size_t count() const;
  [[nodiscard]] size_t sizeData() const;
  [[nodiscard]] size_t sizeImage() const;
  // Todo: This is only implemented in TiffEntryBase. It is needed here so that
  //       we can sort components by tag and idx. Something is not quite right.
  [[nodiscard]] virtual int idx() const;
 
 protected:
 
 
  virtual TiffComponent* doAddPath(uint16_t tag, TiffPath& tiffPath, TiffComponent* pRoot,
                                   TiffComponent::UniquePtr object);
  virtual TiffComponent* doAddChild(UniquePtr tiffComponent);
  virtual TiffComponent* doAddNext(UniquePtr tiffComponent);
  virtual void doAccept(TiffVisitor& visitor) = 0;
  virtual size_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, size_t offset, size_t valueIdx, size_t dataIdx,
                         size_t& imageIdx) = 0;
 
 
 
  [[nodiscard]] virtual TiffComponent* doClone() const = 0;
  virtual size_t doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, size_t offset, size_t dataIdx,
                             size_t& imageIdx) const = 0;
  virtual size_t doWriteImage(IoWrapper& ioWrapper, ByteOrder byteOrder) const = 0;
  [[nodiscard]] virtual size_t doSize() const = 0;
  [[nodiscard]] virtual size_t doCount() const = 0;
  [[nodiscard]] virtual size_t doSizeData() const = 0;
  [[nodiscard]] virtual size_t doSizeImage() const = 0;
 
 private:
  // DATA
  uint16_t tag_;  
  IfdId group_;   
  byte* pStart_{};
};
 
struct TiffMappingInfo {
  struct Key;
  bool operator==(const Key& key) const;
  [[nodiscard]] uint16_t tag() const {
    return static_cast<uint16_t>(extendedTag_ & 0xffff);
  }
 
  // DATA
  const char* make_;       
  uint32_t extendedTag_;   
  IfdId group_;            
  DecoderFct decoderFct_;  
  EncoderFct encoderFct_;  
 
};  // struct TiffMappingInfo
 
struct TiffMappingInfo::Key {
  std::string m_;  
  uint32_t e_;     
  IfdId g_;        
};
 
class TiffEntryBase : public TiffComponent {
  friend class TiffReader;
  friend class TiffEncoder;
 
 public:
 
 
  constexpr TiffEntryBase(uint16_t tag, IfdId group, TiffType tiffType = ttUndefined) :
      TiffComponent(tag, group), tiffType_(tiffType) {
  }
 
  ~TiffEntryBase() override = default;
 
 
 
  TiffEntryBase& operator=(const TiffEntryBase&) = delete;
 
 
 
  void encode(TiffEncoder& encoder, const Exifdatum* datum);
  void setOffset(size_t offset) {
    offset_ = offset;
  }
  void setData(byte* pData, size_t size, std::shared_ptr<DataBuf> storage);
  void setData(std::shared_ptr<DataBuf> buf);
  void updateValue(Value::UniquePtr value, ByteOrder byteOrder);
  void setValue(Value::UniquePtr value);
 
 
 
  [[nodiscard]] TiffType tiffType() const {
    return tiffType_;
  }
  [[nodiscard]] size_t offset() const {
    return offset_;
  }
  [[nodiscard]] int idx() const override;
  [[nodiscard]] const byte* pData() const {
    return pData_;
  }
  [[nodiscard]] const Value* pValue() const {
    return pValue_.get();
  }
 
 protected:
 
 
  TiffEntryBase(const TiffEntryBase& rhs);
 
 
 
  virtual void doEncode(TiffEncoder& encoder, const Exifdatum* datum) = 0;
  void setCount(size_t count) {
    count_ = count;
  }
  void setIdx(int idx) {
    idx_ = idx;
  }
  size_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, size_t offset, size_t valueIdx, size_t dataIdx,
                 size_t& imageIdx) override;
 
 
 
  [[nodiscard]] size_t doCount() const override;
  size_t doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, size_t offset, size_t dataIdx,
                     size_t& imageIdx) const override;
  size_t doWriteImage(IoWrapper& ioWrapper, ByteOrder byteOrder) const override;
  [[nodiscard]] size_t doSize() const override;
  [[nodiscard]] size_t doSizeData() const override;
  [[nodiscard]] size_t doSizeImage() const override;
 
  static size_t writeOffset(byte* buf, size_t offset, TiffType tiffType, ByteOrder byteOrder);
 
  [[nodiscard]] std::shared_ptr<DataBuf> storage() const {
    return storage_;
  }
 
 private:
  // DATA
  TiffType tiffType_;  
  size_t count_{};     
  size_t offset_{};    
  size_t size_{};      
 
  // Notes on the ownership model of pData_: pData_ is a always a
  // pointer to a buffer owned by somebody else. Usually it is a
  // pointer into a copy of the image file, but if
  // TiffEntryBase::setData is used then it is a pointer into the
  // storage_ DataBuf below.
  byte* pData_{};  
 
  int idx_{};                      
  std::unique_ptr<Value> pValue_;  
 
  // This DataBuf is only used when TiffEntryBase::setData is called.
  // Otherwise, it remains empty. It is wrapped in a shared_ptr because
  // TiffEntryBase has a clone method, which could lead to the DataBuf
  // having multiple owners.
  std::shared_ptr<DataBuf> storage_;
};
 
class TiffEntry : public TiffEntryBase {
 public:
 
 
  constexpr TiffEntry(uint16_t tag, IfdId group) : TiffEntryBase(tag, group) {
  }
 
 protected:
 
  void doAccept(TiffVisitor& visitor) override;
  void doEncode(TiffEncoder& encoder, const Exifdatum* datum) override;
 
 
  [[nodiscard]] TiffEntry* doClone() const override;
};
 
class TiffDataEntryBase : public TiffEntryBase {
 public:
 
 
  TiffDataEntryBase(uint16_t tag, IfdId group, uint16_t szTag, IfdId szGroup);
 
 
 
  virtual void setStrips(const Value* pSize, const byte* pData, size_t sizeData, size_t baseOffset) = 0;
 
 
 
  [[nodiscard]] uint16_t szTag() const {
    return szTag_;
  }
  [[nodiscard]] IfdId szGroup() const {
    return szGroup_;
  }
 
 private:
  // DATA
  uint16_t szTag_;  
  IfdId szGroup_;   
};
 
class TiffDataEntry : public TiffDataEntryBase {
  friend class TiffEncoder;
 
 public:
  using TiffDataEntryBase::TiffDataEntryBase;
 
 
  void setStrips(const Value* pSize, const byte* pData, size_t sizeData, size_t baseOffset) override;
 
 protected:
 
  void doAccept(TiffVisitor& visitor) override;
  void doEncode(TiffEncoder& encoder, const Exifdatum* datum) override;
  size_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, size_t offset, size_t valueIdx, size_t dataIdx,
                 size_t& imageIdx) override;
 
 
  [[nodiscard]] TiffDataEntry* doClone() const override;
  size_t doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, size_t offset, size_t dataIdx,
                     size_t& imageIdx) const override;
  // Using doWriteImage from base class
  // Using doSize() from base class
  [[nodiscard]] size_t doSizeData() const override;
  // Using doSizeImage from base class
 
 private:
  // DATA
  byte* pDataArea_{};      
  size_t sizeDataArea_{};  
};
 
class TiffImageEntry : public TiffDataEntryBase {
  friend class TiffEncoder;
  using TiffDataEntryBase::TiffDataEntryBase;
 
 public:
 
  void setStrips(const Value* pSize, const byte* pData, size_t sizeData, size_t baseOffset) override;
 
 protected:
 
  void doAccept(TiffVisitor& visitor) override;
  void doEncode(TiffEncoder& encoder, const Exifdatum* datum) override;
  size_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, size_t offset, size_t valueIdx, size_t dataIdx,
                 size_t& imageIdx) override;
 
 
  [[nodiscard]] TiffImageEntry* doClone() const override;
  size_t doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, size_t offset, size_t dataIdx,
                     size_t& imageIdx) const override;
  size_t doWriteImage(IoWrapper& ioWrapper, ByteOrder byteOrder) const override;
  [[nodiscard]] size_t doSize() const override;
  [[nodiscard]] size_t doSizeData() const override;
  [[nodiscard]] size_t doSizeImage() const override;
 
 private:
  using Strips = std::vector<std::pair<const byte*, size_t>>;
 
  // DATA
  Strips strips_;  
};
 
class TiffSizeEntry : public TiffEntryBase {
 public:
 
 
  constexpr TiffSizeEntry(uint16_t tag, IfdId group, uint16_t dtTag, IfdId dtGroup) :
      TiffEntryBase(tag, group), dtTag_(dtTag), dtGroup_(dtGroup) {
  }
 
 
 
 
  [[nodiscard]] uint16_t dtTag() const {
    return dtTag_;
  }
  [[nodiscard]] IfdId dtGroup() const {
    return dtGroup_;
  }
 
 protected:
 
  void doAccept(TiffVisitor& visitor) override;
  void doEncode(TiffEncoder& encoder, const Exifdatum* datum) override;
 
 
  [[nodiscard]] TiffSizeEntry* doClone() const override;
 
 private:
  // DATA
  uint16_t dtTag_;  
  IfdId dtGroup_;   
};
 
class TiffDirectory : public TiffComponent {
  friend class TiffEncoder;
  friend class TiffDecoder;
 
 public:
 
 
  TiffDirectory(uint16_t tag, IfdId group, bool hasNext = true);
  ~TiffDirectory() override = default;
 
 
 
  TiffDirectory& operator=(const TiffDirectory&) = delete;
 
 
 
  [[nodiscard]] bool hasNext() const {
    return hasNext_;
  }
 
 protected:
 
 
  TiffDirectory(const TiffDirectory& rhs);
 
 
  TiffComponent* doAddPath(uint16_t tag, TiffPath& tiffPath, TiffComponent* pRoot,
                           TiffComponent::UniquePtr object) override;
  TiffComponent* doAddChild(TiffComponent::UniquePtr tiffComponent) override;
  TiffComponent* doAddNext(TiffComponent::UniquePtr tiffComponent) override;
  void doAccept(TiffVisitor& visitor) override;
  size_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, size_t offset, size_t valueIdx, size_t dataIdx,
                 size_t& imageIdx) override;
 
 
  [[nodiscard]] TiffDirectory* doClone() const override;
  size_t doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, size_t offset, size_t dataIdx,
                     size_t& imageIdx) const override;
  size_t doWriteImage(IoWrapper& ioWrapper, ByteOrder byteOrder) const override;
  [[nodiscard]] size_t doSize() const override;
  [[nodiscard]] size_t doCount() const override;
  [[nodiscard]] size_t doSizeData() const override;
  [[nodiscard]] size_t doSizeImage() const override;
 
 private:
 
 
  static size_t writeDirEntry(IoWrapper& ioWrapper, ByteOrder byteOrder, size_t offset, TiffComponent* pTiffComponent,
                              size_t valueIdx, size_t dataIdx, size_t& imageIdx);
 
  // DATA
  Components components_;  
  bool hasNext_;           
  UniquePtr pNext_;        
};
 
class TiffSubIfd : public TiffEntryBase {
  friend class TiffReader;
 
 public:
 
 
  TiffSubIfd(uint16_t tag, IfdId group, IfdId newGroup);
  ~TiffSubIfd() override = default;
 
 
 
  TiffSubIfd(const TiffSubIfd& rhs);
  TiffSubIfd& operator=(const TiffSubIfd&) = delete;
 
 protected:
 
  TiffComponent* doAddPath(uint16_t tag, TiffPath& tiffPath, TiffComponent* pRoot,
                           TiffComponent::UniquePtr object) override;
  TiffComponent* doAddChild(TiffComponent::UniquePtr tiffComponent) override;
  void doAccept(TiffVisitor& visitor) override;
  void doEncode(TiffEncoder& encoder, const Exifdatum* datum) override;
  size_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, size_t offset, size_t valueIdx, size_t dataIdx,
                 size_t& imageIdx) override;
 
 
  [[nodiscard]] TiffSubIfd* doClone() const override;
  size_t doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, size_t offset, size_t dataIdx,
                     size_t& imageIdx) const override;
  size_t doWriteImage(IoWrapper& ioWrapper, ByteOrder byteOrder) const override;
  [[nodiscard]] size_t doSize() const override;
  [[nodiscard]] size_t doSizeData() const override;
  [[nodiscard]] size_t doSizeImage() const override;
 
 private:
  using Ifds = std::vector<std::unique_ptr<TiffDirectory>>;
 
  // DATA
  IfdId newGroup_;  
  Ifds ifds_;       
};
 
class TiffMnEntry : public TiffEntryBase {
  friend class TiffReader;
  friend class TiffDecoder;
  friend class TiffEncoder;
 
 public:
 
 
  constexpr TiffMnEntry(uint16_t tag, IfdId group, IfdId mnGroup) :
      TiffEntryBase(tag, group, ttUndefined), mnGroup_(mnGroup) {
  }
 
 protected:
 
  TiffComponent* doAddPath(uint16_t tag, TiffPath& tiffPath, TiffComponent* pRoot,
                           TiffComponent::UniquePtr object) override;
  TiffComponent* doAddChild(TiffComponent::UniquePtr tiffComponent) override;
  TiffComponent* doAddNext(TiffComponent::UniquePtr tiffComponent) override;
  void doAccept(TiffVisitor& visitor) override;
  void doEncode(TiffEncoder& encoder, const Exifdatum* datum) override;
  size_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, size_t offset, size_t valueIdx, size_t dataIdx,
                 size_t& imageIdx) override;
 
 
  [[nodiscard]] TiffMnEntry* doClone() const override;
  [[nodiscard]] size_t doCount() const override;
  // Using doWriteData from base class
  // Using doWriteImage from base class
  [[nodiscard]] size_t doSize() const override;
  // Using doSizeData from base class
  // Using doSizeImage from base class
 
 private:
  // DATA
  IfdId mnGroup_;                      
  std::unique_ptr<TiffComponent> mn_;  
};
 
class TiffIfdMakernote : public TiffComponent {
  friend class TiffReader;
 
 public:
 
 
  TiffIfdMakernote(uint16_t tag, IfdId group, IfdId mnGroup, std::unique_ptr<MnHeader> pHeader, bool hasNext = true);
  ~TiffIfdMakernote() override;
 
  TiffIfdMakernote(const TiffIfdMakernote&) = delete;
  TiffIfdMakernote& operator=(const TiffIfdMakernote&) = delete;
 
 
 
  bool readHeader(const byte* pData, size_t size, ByteOrder byteOrder);
  void setByteOrder(ByteOrder byteOrder);
  void setImageByteOrder(ByteOrder byteOrder) {
    imageByteOrder_ = byteOrder;
  }
 
 
 
  [[nodiscard]] size_t sizeHeader() const;
  size_t writeHeader(IoWrapper& ioWrapper, ByteOrder byteOrder) const;
  [[nodiscard]] size_t mnOffset() const;
  [[nodiscard]] size_t ifdOffset() const;
  [[nodiscard]] ByteOrder byteOrder() const;
 
  [[nodiscard]] size_t baseOffset() const;
 
 protected:
 
  TiffComponent* doAddPath(uint16_t tag, TiffPath& tiffPath, TiffComponent* pRoot,
                           TiffComponent::UniquePtr object) override;
  TiffComponent* doAddChild(TiffComponent::UniquePtr tiffComponent) override;
  TiffComponent* doAddNext(TiffComponent::UniquePtr tiffComponent) override;
  void doAccept(TiffVisitor& visitor) override;
  size_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, size_t offset, size_t valueIdx, size_t dataIdx,
                 size_t& imageIdx) override;
 
 
  [[nodiscard]] TiffIfdMakernote* doClone() const override;
  size_t doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, size_t offset, size_t dataIdx,
                     size_t& imageIdx) const override;
  size_t doWriteImage(IoWrapper& ioWrapper, ByteOrder byteOrder) const override;
  [[nodiscard]] size_t doSize() const override;
  [[nodiscard]] size_t doCount() const override;
  [[nodiscard]] size_t doSizeData() const override;
  [[nodiscard]] size_t doSizeImage() const override;
 
 private:
  // DATA
  std::unique_ptr<MnHeader> pHeader_;           
  TiffDirectory ifd_;                           
  size_t mnOffset_{};                           
  ByteOrder imageByteOrder_{invalidByteOrder};  
};
 
using CfgSelFct = int (*)(uint16_t, const byte*, size_t, TiffComponent*);
 
using CryptFct = DataBuf (*)(uint16_t, const byte*, size_t, TiffComponent*);
 
struct ArrayDef {
  bool operator==(size_t idx) const {
    return idx_ == idx;
  }
  [[nodiscard]] size_t size(uint16_t tag, IfdId group) const;
  // DATA
  size_t idx_;         
  TiffType tiffType_;  
  size_t count_;       
};
 
struct ArrayCfg {
  [[nodiscard]] size_t tagStep() const {
    return elDefaultDef_.size(0, group_);
  }
  // DATA
  IfdId group_;            
  ByteOrder byteOrder_;    
  TiffType elTiffType_;    
  CryptFct cryptFct_;      
  bool hasSize_;           
  bool hasFillers_;        
  bool concat_;            
  ArrayDef elDefaultDef_;  
};
 
struct ArraySet {
  ArrayCfg cfg_;         
  const ArrayDef* def_;  
  size_t defSize_;       
};
 
class TiffBinaryArray : public TiffEntryBase {
 public:
 
 
  TiffBinaryArray(uint16_t tag, IfdId group, const ArrayCfg& arrayCfg, const ArrayDef* arrayDef, size_t defSize);
  TiffBinaryArray(uint16_t tag, IfdId group, const ArraySet* arraySet, size_t setSize, CfgSelFct cfgSelFct);
  ~TiffBinaryArray() override = default;
  TiffBinaryArray& operator=(const TiffBinaryArray&) = delete;
 
 
 
  size_t addElement(size_t idx, const ArrayDef& def);
  bool initialize(IfdId group);
  bool initialize(TiffComponent* pRoot);
  void iniOrigDataBuf();
  bool updOrigDataBuf(const byte* pData, size_t size);
  void setDecoded(bool decoded) {
    decoded_ = decoded;
  }
 
 
 
  [[nodiscard]] const ArrayCfg* cfg() const {
    return arrayCfg_;
  }
  [[nodiscard]] const ArrayDef* def() const {
    return arrayDef_;
  }
  [[nodiscard]] size_t defSize() const {
    return defSize_;
  }
  [[nodiscard]] bool decoded() const {
    return decoded_;
  }
 
 protected:
 
 
  TiffBinaryArray(const TiffBinaryArray& rhs);
 
 
 
  TiffComponent* doAddPath(uint16_t tag, TiffPath& tiffPath, TiffComponent* pRoot,
                           TiffComponent::UniquePtr object) override;
  TiffComponent* doAddChild(TiffComponent::UniquePtr tiffComponent) override;
  void doAccept(TiffVisitor& visitor) override;
  void doEncode(TiffEncoder& encoder, const Exifdatum* datum) override;
  size_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, size_t offset, size_t valueIdx, size_t dataIdx,
                 size_t& imageIdx) override;
 
 
  [[nodiscard]] TiffBinaryArray* doClone() const override;
  [[nodiscard]] size_t doCount() const override;
  // Using doWriteData from base class
  // Using doWriteImage from base class
  [[nodiscard]] size_t doSize() const override;
  // Using doSizeData from base class
  // Using doSizeImage from base class
 
 private:
  // DATA
  CfgSelFct cfgSelFct_{};       
  const ArraySet* arraySet_{};  
  const ArrayCfg* arrayCfg_{};  
  const ArrayDef* arrayDef_{};  
  size_t defSize_{};            
  size_t setSize_{};            
  Components elements_;         
  byte* origData_{};            
  size_t origSize_{};           
  TiffComponent* pRoot_{};      
  bool decoded_{};              
};
 
class TiffBinaryElement : public TiffEntryBase {
  using TiffEntryBase::TiffEntryBase;
 
 public:
 
 
  void setElDef(const ArrayDef& def) {
    elDef_ = def;
  }
  void setElByteOrder(ByteOrder byteOrder) {
    elByteOrder_ = byteOrder;
  }
 
 
 
  [[nodiscard]] const ArrayDef* elDef() const {
    return &elDef_;
  }
  [[nodiscard]] ByteOrder elByteOrder() const {
    return elByteOrder_;
  }
 
 protected:
 
  void doAccept(TiffVisitor& visitor) override;
  void doEncode(TiffEncoder& encoder, const Exifdatum* datum) override;
  size_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, size_t offset, size_t valueIdx, size_t dataIdx,
                 size_t& imageIdx) override;
 
 
  [[nodiscard]] TiffBinaryElement* doClone() const override;
  [[nodiscard]] size_t doCount() const override;
  // Using doWriteData from base class
  // Using doWriteImage from base class
  [[nodiscard]] size_t doSize() const override;
  // Using doSizeData from base class
  // Using doSizeImage from base class
 
 private:
  // DATA
  ArrayDef elDef_{0, ttUndefined, 0};        
  ByteOrder elByteOrder_{invalidByteOrder};  
};
 
// *****************************************************************************
// template, inline and free functions
 
bool cmpTagLt(const TiffComponent::UniquePtr& lhs, const TiffComponent::UniquePtr& rhs);
 
bool cmpGroupLt(const std::unique_ptr<TiffDirectory>& lhs, const std::unique_ptr<TiffDirectory>& rhs);
 
TiffComponent::UniquePtr newTiffEntry(uint16_t tag, IfdId group);
 
TiffComponent::UniquePtr newTiffMnEntry(uint16_t tag, IfdId group);
 
TiffComponent::UniquePtr newTiffBinaryElement(uint16_t tag, IfdId group);
 
template <IfdId newGroup>
TiffComponent::UniquePtr newTiffDirectory(uint16_t tag, IfdId /*group*/) {
  return std::make_unique<TiffDirectory>(tag, newGroup);
}
 
template <IfdId newGroup>
TiffComponent::UniquePtr newTiffSubIfd(uint16_t tag, IfdId group) {
  return std::make_unique<TiffSubIfd>(tag, group, newGroup);
}
 
template <const ArrayCfg& arrayCfg, size_t N, const ArrayDef (&arrayDef)[N]>
TiffComponent::UniquePtr newTiffBinaryArray0(uint16_t tag, IfdId group) {
  return std::make_unique<TiffBinaryArray>(tag, group, arrayCfg, arrayDef, N);
}
 
template <const ArrayCfg& arrayCfg>
TiffComponent::UniquePtr newTiffBinaryArray1(uint16_t tag, IfdId group) {
  return std::make_unique<TiffBinaryArray>(tag, group, arrayCfg, nullptr, 0);
}
 
template <size_t N, const ArraySet (&arraySet)[N], CfgSelFct cfgSelFct>
TiffComponent::UniquePtr newTiffBinaryArray2(uint16_t tag, IfdId group) {
  return std::make_unique<TiffBinaryArray>(tag, group, arraySet, N, cfgSelFct);
}
 
template <uint16_t szTag, IfdId szGroup>
TiffComponent::UniquePtr newTiffThumbData(uint16_t tag, IfdId group) {
  return std::make_unique<TiffDataEntry>(tag, group, szTag, szGroup);
}
 
template <uint16_t dtTag, IfdId dtGroup>
TiffComponent::UniquePtr newTiffThumbSize(uint16_t tag, IfdId group) {
  return std::make_unique<TiffSizeEntry>(tag, group, dtTag, dtGroup);
}
 
template <uint16_t szTag, IfdId szGroup>
TiffComponent::UniquePtr newTiffImageData(uint16_t tag, IfdId group) {
  return std::make_unique<TiffImageEntry>(tag, group, szTag, szGroup);
}
 
template <uint16_t dtTag, IfdId dtGroup>
TiffComponent::UniquePtr newTiffImageSize(uint16_t tag, IfdId group) {
  // Todo: Same as newTiffThumbSize - consolidate (rename)?
  return std::make_unique<TiffSizeEntry>(tag, group, dtTag, dtGroup);
}
 
}  // namespace Internal
}  // namespace Exiv2
 
#endif  // #ifndef TIFFCOMPOSITE_INT_HPP_