Exiv2

    class EXIV2API BasicIo {

    public:

        //! BasicIo auto_ptr type

        typedef std::auto_ptr<BasicIo> AutoPtr;

        //! Seek starting positions

        enum Position { beg, cur, end };

    class EXIV2API IptcKey : public Key {

    public:

        //! Shortcut for an %IptcKey auto pointer.

        typedef std::auto_ptr<IptcKey> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API Key {

    public:

        //! Shortcut for a %Key auto pointer.

        typedef std::auto_ptr<Key> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API XmpKey : public Key {

    public:

        //! Shortcut for an %XmpKey auto pointer.

        typedef std::auto_ptr<XmpKey> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API ExifKey : public Key {

    public:

        //! Shortcut for an %ExifKey auto pointer.

        typedef std::auto_ptr<ExifKey> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API Value {

    public:

        //! Shortcut for a %Value auto pointer.

        typedef std::auto_ptr<Value> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API DataValue : public Value {

    public:

        //! Shortcut for a %DataValue auto pointer.

        typedef std::auto_ptr<DataValue> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API StringValueBase : public Value {

    public:

        //! Shortcut for a %StringValueBase auto pointer.

        typedef std::auto_ptr<StringValueBase> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API StringValue : public StringValueBase {

    public:

        //! Shortcut for a %StringValue auto pointer.

        typedef std::auto_ptr<StringValue> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API AsciiValue : public StringValueBase {

    public:

        //! Shortcut for a %AsciiValue auto pointer.

        typedef std::auto_ptr<AsciiValue> AutoPtr;

        //! @name Creators

        //@{

        }; // class CharsetInfo

        //! Shortcut for a %CommentValue auto pointer.

        typedef std::auto_ptr<CommentValue> AutoPtr;

        //! @name Creators

        //@{

    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 };

    class EXIV2API XmpTextValue : public XmpValue {

    public:

        //! Shortcut for a %XmpTextValue auto pointer.

        typedef std::auto_ptr<XmpTextValue> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API XmpArrayValue : public XmpValue {

    public:

        //! Shortcut for a %XmpArrayValue auto pointer.

        typedef std::auto_ptr<XmpArrayValue> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API LangAltValue : public XmpValue {

    public:

        //! Shortcut for a %LangAltValue auto pointer.

        typedef std::auto_ptr<LangAltValue> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API DateValue : public Value {

    public:

        //! Shortcut for a %DateValue auto pointer.

        typedef std::auto_ptr<DateValue> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API TimeValue : public Value {

    public:

        //! Shortcut for a %TimeValue auto pointer.

        typedef std::auto_ptr<TimeValue> AutoPtr;

        //! @name Creators

        //@{

    class ValueType : public Value {

    public:

        //! Shortcut for a %ValueType\<T\> auto pointer.

        typedef std::auto_ptr<ValueType<T> > AutoPtr;

        //! @name Creators

        //@{

    Exiv2::BasicIo::AutoPtr memIo(new Exiv2::MemIo);

    memIo->transfer(*fileIo);

    Exiv2::Image::AutoPtr readImg = Exiv2::ImageFactory::open(memIo);

    assert(readImg.get() != 0);

    readImg->readMetadata();

            Task* t = i->second;

            return t->clone();

        }

        return Task::AutoPtr(0);

    } // TaskFactory::create

    Print::~Print()

                      << _("Failed to open the file\n");

            return -1;

        }

        assert(image.get() != 0);

        image->readMetadata();

        Exiv2::ExifData& exifData = image->exifData();

        if ( bStdin )  Params::instance().getStdin(stdIn);

        Exiv2::BasicIo::AutoPtr ioStdin = Exiv2::BasicIo::AutoPtr(new Exiv2::MemIo(stdIn.pData_,stdIn.size_));

        Exiv2::Image::AutoPtr sourceImage = bStdin ? Exiv2::ImageFactory::open(ioStdin) : Exiv2::ImageFactory::open(source);

        assert(sourceImage.get() != 0);

        sourceImage->readMetadata();

    class Task {

    public:

        //! Shortcut for an auto pointer.

        typedef std::auto_ptr<Task> AutoPtr;

        //! Virtual destructor.

        virtual ~Task();

        //! Virtual copy construction.

    public:

        virtual ~Print();

        virtual int run(const std::string& path);

        typedef std::auto_ptr<Print> AutoPtr;

        AutoPtr clone() const;

        //! Print the Jpeg comment

    public:

        virtual ~Rename();

        virtual int run(const std::string& path);

        typedef std::auto_ptr<Rename> AutoPtr;

        AutoPtr clone() const;

    private:

    public:

        virtual ~Adjust();

        virtual int run(const std::string& path);

        typedef std::auto_ptr<Adjust> AutoPtr;

        AutoPtr clone() const;

    private:

    public:

        virtual ~Erase();

        virtual int run(const std::string& path);

        typedef std::auto_ptr<Erase> AutoPtr;

        AutoPtr clone() const;

        /*!

    public:

        virtual ~Extract();

        virtual int run(const std::string& path);

        typedef std::auto_ptr<Extract> AutoPtr;

        AutoPtr clone() const;

        /*!

    public:

        virtual ~Insert();

        virtual int run(const std::string& path);

        typedef std::auto_ptr<Insert> AutoPtr;

        AutoPtr clone() const;

        /*!

    public:

        virtual ~Modify();

        virtual int run(const std::string& path);

        typedef std::auto_ptr<Modify> AutoPtr;

        AutoPtr clone() const;

        Modify() {}

        //! Apply modification commands to the \em pImage, return 0 if successful.

    public:

        virtual ~FixIso();

        virtual int run(const std::string& path);

        typedef std::auto_ptr<FixIso> AutoPtr;

        AutoPtr clone() const;

    private:

    public:

        virtual ~FixCom();

        virtual int run(const std::string& path);

        typedef std::auto_ptr<FixCom> AutoPtr;

        AutoPtr clone() const;

    private:

    using namespace Exiv2::Internal;

    AsfVideo::AsfVideo(BasicIo::AutoPtr io)

        : Image(ImageType::asf, mdNone, io)

    {

    } // AsfVideo::AsfVideo

    std::string AsfVideo::mimeType() const

    {

    Image::AutoPtr newAsfInstance(BasicIo::AutoPtr io, bool /*create*/)

    {

        Image::AutoPtr image(new AsfVideo(io));

        if (!image->good()) {

            image.reset();

        }

        // buffer, which is a workaround to ensure that the links don't get broken.

        if (ret != 0 || (buf.st_size > 1048576 && nlink == 1)) {

            pid_t pid = ::getpid();

            std::auto_ptr<FileIo> fileIo;

#ifdef EXV_UNICODE_PATH

            if (p_->wpMode_ == Impl::wpUnicode) {

                std::wstring tmpname = wpath() + s2ws(toString(pid));

                fileIo = std::auto_ptr<FileIo>(new FileIo(tmpname));

            }

            else

#endif

            {

                std::string tmpname = path() + toString(pid);

                fileIo = std::auto_ptr<FileIo>(new FileIo(tmpname));

            }

            if (fileIo->open("w+b") != 0) {

#ifdef EXV_UNICODE_PATH

                }

            }

            fileIo->p_->copyXattrFrom(*this);

            basicIo = fileIo;

        }

        else {

            basicIo.reset(new MemIo);

// class member definitions

namespace Exiv2 {

    BmpImage::BmpImage(BasicIo::AutoPtr io)

        : Image(ImageType::bmp, mdNone, io)

    {

    } // BmpImage::BmpImage

    std::string BmpImage::mimeType() const

    {

    // free functions

    Image::AutoPtr newBmpInstance(BasicIo::AutoPtr io, bool /*create*/)

    {

        Image::AutoPtr image(new BmpImage(io));

        if (!image->good())

        {

            image.reset();

    using namespace Internal;

    Cr2Image::Cr2Image(BasicIo::AutoPtr io, bool /*create*/)

        : Image(ImageType::cr2, mdExif | mdIptc | mdXmp, io)

    {

    } // Cr2Image::Cr2Image

                     ed.end());

        }

        std::auto_ptr<TiffHeaderBase> header(new Cr2Header(byteOrder));

        OffsetWriter offsetWriter;

        offsetWriter.setOrigin(OffsetWriter::cr2RawIfdOffset, Cr2Header::offset2addr(), byteOrder);

        return TiffParserWorker::encode(io,

    // free functions

    Image::AutoPtr newCr2Instance(BasicIo::AutoPtr io, bool create)

    {

        Image::AutoPtr image(new Cr2Image(io, create));

        if (!image->good()) {

            image.reset();

        }

    using namespace Internal;

    CrwImage::CrwImage(BasicIo::AutoPtr io, bool /*create*/)

        : Image(ImageType::crw, mdExif | mdComment, io)

    {

    } // CrwImage::CrwImage

    // free functions

    Image::AutoPtr newCrwInstance(BasicIo::AutoPtr io, bool create)

    {

        Image::AutoPtr image(new CrwImage(io, create));

        if (!image->good()) {

            image.reset();

        }

    void CiffComponent::add(AutoPtr component)

    {

        doAdd(component);

    }

    void CiffEntry::doAdd(AutoPtr /*component*/)

            }

            m->setDir(this->tag());

            m->read(pData, size, o, byteOrder);

            add(m);

            o += 10;

        }

    }  // CiffDirectory::readDirectory

                // Directory doesn't exist yet, add it

                m_ = AutoPtr(new CiffDirectory(csd.crwDir_, csd.parent_));

                cc_ = m_.get();

                add(m_);

            }

            // Recursive call to next lower level directory

            cc_ = cc_->add(crwDirs, crwTagId);

                // Tag doesn't exist yet, add it

                m_ = AutoPtr(new CiffEntry(crwTagId, tag()));

                cc_ = m_.get();

                add(m_);

            }

        }

        return cc_;

    class CiffComponent {

    public:

        //! CiffComponent auto_ptr type

        typedef std::auto_ptr<CiffComponent> AutoPtr;

        //! Container type to hold all metadata

        typedef std::vector<CiffComponent*> Components;

    class CiffHeader {

    public:

        //! CiffHeader auto_ptr type

        typedef std::auto_ptr<CiffHeader> AutoPtr;

        //! @name Creators

        //@{

namespace Exiv2

{

    EpsImage::EpsImage(BasicIo::AutoPtr io, bool create)

            : Image(ImageType::eps, mdXmp, io)

    {

        //LogMsg::setLevel(LogMsg::debug);

        if (create) {

    // free functions

    Image::AutoPtr newEpsInstance(BasicIo::AutoPtr io, bool create)

    {

        Image::AutoPtr image(new EpsImage(io, create));

        if (!image->good()) {

            image.reset();

        }

    class Thumbnail {

    public:

        //! Shortcut for a %Thumbnail auto pointer.

        typedef std::auto_ptr<Thumbnail> AutoPtr;

        //! @name Creators

        //@{

    class TiffThumbnail : public Thumbnail {

    public:

        //! Shortcut for a %TiffThumbnail auto pointer.

        typedef std::auto_ptr<TiffThumbnail> AutoPtr;

        //! @name Manipulators

        //@{

    class JpegThumbnail : public Thumbnail {

    public:

        //! Shortcut for a %JpegThumbnail auto pointer.

        typedef std::auto_ptr<JpegThumbnail> AutoPtr;

        //! @name Manipulators

        //@{

    template<typename T>

    Exiv2::Exifdatum& setValue(Exiv2::Exifdatum& exifDatum, const T& value)

    {

        std::auto_ptr<Exiv2::ValueType<T> > v

            = std::auto_ptr<Exiv2::ValueType<T> >(new Exiv2::ValueType<T>);

        v->value_.push_back(value);

        exifDatum.value_ = v;

        return exifDatum;

    }

    Value::AutoPtr Exifdatum::getValue() const

    {

        return value_.get() == 0 ? Value::AutoPtr(0) : value_->clone();

    }

    long Exifdatum::sizeDataArea() const

        // Encode and check if the result fits into a JPEG Exif APP1 segment

        MemIo mio1;

        std::auto_ptr<TiffHeaderBase> header(new TiffHeader(byteOrder, 0x00000008, false));

        WriteMethod wm = TiffParserWorker::encode(mio1,

                                                  pData,

                                                  size,

// class member definitions

namespace Exiv2 {

    GifImage::GifImage(BasicIo::AutoPtr io)

        : Image(ImageType::gif, mdNone, io)

    {

    } // GifImage::GifImage

    // free functions

    Image::AutoPtr newGifInstance(BasicIo::AutoPtr io, bool /*create*/)

    {

        Image::AutoPtr image(new GifImage(io));

        if (!image->good())

        {

            image.reset();

    Image::Image(int              imageType,

                 uint16_t         supportedMetadata,

                 BasicIo::AutoPtr io)

        : io_(io),

          pixelWidth_(0),

          pixelHeight_(0),

          imageType_(imageType),

    Image::AutoPtr ImageFactory::open(const byte* data, long size)

    {

        BasicIo::AutoPtr io(new MemIo(data, size));

        Image::AutoPtr image = open(io); // may throw

        if (image.get() == 0) throw Error(12);

        return image;

    }

        }

        for (unsigned int i = 0; registry[i].imageType_ != ImageType::none; ++i) {

            if (registry[i].isThisType_(*io, false)) {

                return registry[i].newInstance_(io, false);

            }

        }

        return Image::AutoPtr();

    Image::AutoPtr ImageFactory::create(int type,

                                        const std::string& path)

    {

        std::auto_ptr<FileIo> fileIo(new FileIo(path));

        // Create or overwrite the file, then close it

        if (fileIo->open("w+b") != 0) {

            throw Error(10, path, "w+b", strError());

        }

        fileIo->close();

        BasicIo::AutoPtr io(fileIo);

        Image::AutoPtr image = create(type, io);

        if (image.get() == 0) throw Error(13, type);

        return image;

    }

    Image::AutoPtr ImageFactory::create(int type,

                                        const std::wstring& wpath)

    {

        std::auto_ptr<FileIo> fileIo(new FileIo(wpath));

        // Create or overwrite the file, then close it

        if (fileIo->open("w+b") != 0) {

            throw WError(10, wpath, "w+b", strError().c_str());

    Image::AutoPtr ImageFactory::create(int type)

    {

        BasicIo::AutoPtr io(new MemIo);

        Image::AutoPtr image = create(type, io);

        if (image.get() == 0) throw Error(13, type);

        return image;

    }

        // BasicIo instance does not need to be open

        const Registry* r = find(registry, type);

        if (0 != r) {

            return r->newInstance_(io, true);

        }

        return Image::AutoPtr();

    } // ImageFactory::create

    Value::AutoPtr Iptcdatum::getValue() const

    {

        return value_.get() == 0 ? Value::AutoPtr(0) : value_->clone();

    }

    const Value& Iptcdatum::value() const

    {

        UShortValue::AutoPtr v(new UShortValue);

        v->value_.push_back(value);

        value_ = v;

        return *this;

    }

namespace Exiv2

{

    Jp2Image::Jp2Image(BasicIo::AutoPtr io, bool create)

            : Image(ImageType::jp2, mdExif | mdIptc | mdXmp, io)

    {

        if (create)

        {

    // free functions

    Image::AutoPtr newJp2Instance(BasicIo::AutoPtr io, bool create)

    {

        Image::AutoPtr image(new Jp2Image(io, create));

        if (!image->good())

        {

            image.reset();

    } // Photoshop::setIptcIrb

    JpegBase::JpegBase(int type, BasicIo::AutoPtr io, bool create,

                       const byte initData[], long dataSize)

        : Image(type, mdExif | mdIptc | mdXmp | mdComment, io)

    {

        if (create) {

            initImage(initData, dataSize);

        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xDA,0x00,0x0C,0x03,0x01,0x00,0x02,

        0x11,0x03,0x11,0x00,0x3F,0x00,0xA0,0x00,0x0F,0xFF,0xD9 };

    JpegImage::JpegImage(BasicIo::AutoPtr io, bool create)

        : JpegBase(ImageType::jpeg, io, create, blank_, sizeof(blank_))

    {

    }

    Image::AutoPtr newJpegInstance(BasicIo::AutoPtr io, bool create)

    {

        Image::AutoPtr image(new JpegImage(io, create));

        if (!image->good()) {

            image.reset();

        }

    const char ExvImage::exiv2Id_[] = "Exiv2";

    const byte ExvImage::blank_[] = { 0xff,0x01,'E','x','i','v','2',0xff,0xd9 };

    ExvImage::ExvImage(BasicIo::AutoPtr io, bool create)

        : JpegBase(ImageType::exv, io, create, blank_, sizeof(blank_))

    {

    }

    Image::AutoPtr newExvInstance(BasicIo::AutoPtr io, bool create)

    {

        Image::AutoPtr image;

        image = Image::AutoPtr(new ExvImage(io, create));

        if (!image->good()) image.reset();

        return image;

    }

    using namespace Exiv2::Internal;

    MatroskaVideo::MatroskaVideo(BasicIo::AutoPtr io)

        : Image(ImageType::mkv, mdNone, io)

    {

    } // MatroskaVideo::MatroskaVideo

    Image::AutoPtr newMkvInstance(BasicIo::AutoPtr io, bool /*create*/)

    {

        Image::AutoPtr image(new MatroskaVideo(io));

        if (!image->good()) {

            image.reset();

        }

// class member definitions

namespace Exiv2 {

    MrwImage::MrwImage(BasicIo::AutoPtr io, bool /*create*/)

        : Image(ImageType::mrw, mdExif | mdIptc | mdXmp, io)

    {

    } // MrwImage::MrwImage

    // free functions

    Image::AutoPtr newMrwInstance(BasicIo::AutoPtr io, bool create)

    {

        Image::AutoPtr image(new MrwImage(io, create));

        if (!image->good()) {

            image.reset();

        }

    using namespace Internal;

    OrfImage::OrfImage(BasicIo::AutoPtr io, bool create)

        : TiffImage(/*ImageType::orf, mdExif | mdIptc | mdXmp,*/ io,create)

    {

    	setTypeSupported(ImageType::orf, mdExif | mdIptc | mdXmp);

    } // OrfImage::OrfImage

                     ed.end());

        }

        std::auto_ptr<TiffHeaderBase> header(new OrfHeader(byteOrder));

        return TiffParserWorker::encode(io,

                                        pData,

                                        size,

    // free functions

    Image::AutoPtr newOrfInstance(BasicIo::AutoPtr io, bool create)

    {

        Image::AutoPtr image(new OrfImage(io, create));

        if (!image->good()) {

            image.reset();

        }

        return result;

    }

    PgfImage::PgfImage(BasicIo::AutoPtr io, bool create)

            : Image(ImageType::pgf, mdExif | mdIptc| mdXmp | mdComment, io)

            , bSwap_(isBigEndianPlatform())

    {

        if (create)

        {

    // free functions

    Image::AutoPtr newPgfInstance(BasicIo::AutoPtr io, bool create)

    {

        Image::AutoPtr image(new PgfImage(io, create));

        if (!image->good())

        {

            image.reset();

    using namespace Internal;

    PngImage::PngImage(BasicIo::AutoPtr io, bool create)

            : Image(ImageType::png, mdExif | mdIptc | mdXmp | mdComment, io)

    {

        if (create)

        {

    // free functions

    Image::AutoPtr newPngInstance(BasicIo::AutoPtr io, bool create)

    {

        Image::AutoPtr image(new PngImage(io, create));

        if (!image->good())

        {

            image.reset();

        virtual ~Loader() {}

        //! Loader auto pointer

        typedef std::auto_ptr<Loader> AutoPtr;

        //! Create a Loader subclass for requested id

        static AutoPtr create(PreviewId id, const Image &image);

// class member definitions

namespace Exiv2 {

    PsdImage::PsdImage(BasicIo::AutoPtr io)

        : Image(ImageType::psd, mdExif | mdIptc | mdXmp, io)

    {

    } // PsdImage::PsdImage

    // free functions

    Image::AutoPtr newPsdInstance(BasicIo::AutoPtr io, bool /*create*/)

    {

        Image::AutoPtr image(new PsdImage(io));

        if (!image->good())

        {

            image.reset();

    using namespace Exiv2::Internal;

    QuickTimeVideo::QuickTimeVideo(BasicIo::AutoPtr io)

            : Image(ImageType::qtime, mdNone, io)

            , timeScale_(1)

    {

    } // QuickTimeVideo::QuickTimeVideo

    Image::AutoPtr newQTimeInstance(BasicIo::AutoPtr io, bool /*create*/) {

        Image::AutoPtr image(new QuickTimeVideo(io));

        if (!image->good()) {

            image.reset();

        }

// class member definitions

namespace Exiv2 {

    RafImage::RafImage(BasicIo::AutoPtr io, bool /*create*/)

        : Image(ImageType::raf, mdExif | mdIptc | mdXmp, io)

    {

    } // RafImage::RafImage

    // free functions

    Image::AutoPtr newRafInstance(BasicIo::AutoPtr io, bool create)

    {

        Image::AutoPtr image(new RafImage(io, create));

        if (!image->good()) {

            image.reset();

        }

namespace Exiv2 {

    using namespace Exiv2::Internal;

    RiffVideo::RiffVideo(BasicIo::AutoPtr io)

            : Image(ImageType::riff, mdNone, io)

    {

    } // RiffVideo::RiffVideo

    Image::AutoPtr newRiffInstance(BasicIo::AutoPtr io, bool /*create*/)

    {

        Image::AutoPtr image(new RiffVideo(io));

        if (!image->good()) {

            image.reset();

        }

    using namespace Internal;

    Rw2Image::Rw2Image(BasicIo::AutoPtr io)

        : Image(ImageType::rw2, mdExif | mdIptc | mdXmp, io)

    {

    } // Rw2Image::Rw2Image

    // free functions

    Image::AutoPtr newRw2Instance(BasicIo::AutoPtr io, bool /*create*/)

    {

        Image::AutoPtr image(new Rw2Image(io));

        if (!image->good()) {

            image.reset();

        }

// class member definitions

namespace Exiv2 {

    TgaImage::TgaImage(BasicIo::AutoPtr io)

        : Image(ImageType::tga, mdNone, io)

    {

    } // TgaImage::TgaImage

    // free functions

    Image::AutoPtr newTgaInstance(BasicIo::AutoPtr io, bool /*create*/)

    {

        Image::AutoPtr image(new TgaImage(io));

        if (!image->good())

        {

            image.reset();

        memset(pData_, 0x0, size_);

        size_ = value->copy(pData_, byteOrder);

        assert(size_ == newSize);

        setValue(value);

    } // TiffEntryBase::updateValue

    void TiffEntryBase::setValue(Value::AutoPtr value)

        tp->setData(const_cast<byte*>(pData() + idx), sz);

        tp->setElDef(def);

        tp->setElByteOrder(cfg()->byteOrder_);

        addChild(tc);

        return sz;

    } // TiffBinaryArray::addElement

                                          TiffComponent* const pRoot,

                                          TiffComponent::AutoPtr object)

    {

        return doAddPath(tag, tiffPath, pRoot, object);

    } // TiffComponent::addPath

    TiffComponent* TiffComponent::doAddPath(uint16_t  /*tag*/,

        if (tc == 0) {

            TiffComponent::AutoPtr atc;

            if (tiffPath.size() == 1 && object.get() != 0) {

                atc = object;

            }

            else {

                atc = TiffCreator::create(tpi.extendedTag(), tpi.group());

            if (tiffPath.size() == 1 && dynamic_cast<TiffSubIfd*>(atc.get()) != 0) return 0;

            if (tpi.extendedTag() == Tag::next) {

                tc = this->addNext(atc);

            }

            else {

                tc = this->addChild(atc);

            }

        }

        return tc->addPath(tag, tiffPath, pRoot, object);

    } // TiffDirectory::doAddPath

    TiffComponent* TiffSubIfd::doAddPath(uint16_t tag,

        }

        if (tc == 0) {

            if (tiffPath.size() == 1 && object.get() != 0) {

                tc = addChild(object);

            }

            else {

                TiffComponent::AutoPtr atc(new TiffDirectory(tpi1.tag(), tpi2.group()));

                tc = addChild(atc);

            }

            setCount(static_cast<uint32_t>(ifds_.size()));

        }

        return tc->addPath(tag, tiffPath, pRoot, object);

    } // TiffSubIfd::doAddPath

    TiffComponent* TiffMnEntry::doAddPath(uint16_t tag,

            mn_ = TiffMnCreator::create(tpi1.tag(), tpi1.group(), mnGroup_);

            assert(mn_);