PwpAnchoredFileValue.h

Go to the documentation of this file.

/****************************************************************************
 *
 * template class PwpAnchoredFileValue
 * template struct PwpAnchoredFileValueWriter
 *
 * (C) 2021 Cadence Design Systems, Inc. All rights reserved worldwide.
 *
 ***************************************************************************/
 
#ifndef _PWPANCHOREDFILEVALUE_H_
#define _PWPANCHOREDFILEVALUE_H_
 
#include "PwpFile.h"
#include "pwpPlatform.h"
 
 
template< typename ValType >
struct PwpAnchoredFileValueWriter {
 
    static bool writeBin(bool placeholder, PwpFile &f, const ValType &v,
        PWP_INT fldWidth, const char * suffix, const char * prefix)
    {
        (void)placeholder;
        (void)fldWidth;
        return f.write(v, suffix, prefix);
    }
 
 
 
    static bool writeAsc(bool placeholder, PwpFile &f, const ValType &v,
        PWP_INT fldWidth, const char * suffix, const char * prefix)
    {
        (void)placeholder;
        return 0 != fprintf(f, "%s%*u%s", (prefix ? prefix : ""), (int)fldWidth,
            (unsigned int)v, (suffix ? suffix : ""));
    }
 
 
 
    static bool writeUnf(bool placeholder, PwpFile &f, const ValType &v,
        PWP_INT fldWidth, const char * suffix, const char * prefix)
    {
        (void)fldWidth;
        bool ret = false;
        if (placeholder) {
            // Writing the placeholder data value. Write normally so that the
            // unf record byte count will properly increment.
            ret = f.write(v, suffix, prefix);
        }
        else {
            // Update anchored value. Bypass unf data handling and write value
            // directly.
            const void *p = PwuApplyEndianness(f.getByteOrder(), &v, sizeof(v));
            ret = (1 == pwpFileWrite(p, sizeof(v), 1, f));
        }
        return ret;
    }
};
 
 
template< typename ValType,
          typename ValWriter = PwpAnchoredFileValueWriter<ValType> >
class PwpAnchoredFileValue {
public:
 
 
    PwpAnchoredFileValue(PwpFile &f) :
        anchored_(false),
        v_(),
        suffix_(0),
        prefix_(0),
        f_(f),
        fldWidth_(-1) // -1 is left-aligned, packed
    {
    }
 
 
 
    PwpAnchoredFileValue(PwpFile &f, const ValType &initV,
            const char * suffix = 0, const char * prefix = 0,
            PWP_INT fldWidth = -1) :
        anchored_(false),
        v_(initV),
        suffix_(suffix),
        prefix_(prefix),
        f_(f),
        fldWidth_(fldWidth) // -1 is left-aligned, packed
    {
    }
 
 
 
    PwpAnchoredFileValue(PwpFile &f, const ValType &initV, PWP_INT fldWidth,
            const char * suffix = 0, const char * prefix = 0) :
        anchored_(false),
        v_(initV),
        suffix_(suffix),
        prefix_(prefix),
        f_(f),
        fldWidth_(fldWidth)
    {
    }
 
 
    ~PwpAnchoredFileValue()
    {
    }
 
 
 
    bool anchor(const char * suffix = 0, const char * prefix = 0,
            PWP_INT fldWidth = 0)
    {
        if (0 != suffix) {
            suffix_ = suffix;
        }
        if (0 != prefix) {
            prefix_ = prefix;
        }
        if (0 != fldWidth) {
            fldWidth_ = fldWidth;
        }
        anchored_ = f_.getPos(pos_) && write();
        return anchored_;
    }
 
 
 
    bool anchor(PWP_INT fldWidth, const char * suffix = 0,
        const char * prefix = 0)
    {
        return anchor(suffix, prefix, fldWidth);
    }
 
 
 
    bool commit()
    {
        sysFILEPOS posSave;
        return anchored_ && f_.getPos(posSave) && f_.setPos(pos_) &&
            write() && f_.setPos(posSave);
    }
 
 
 
    bool rollback()
    {
        bool ret = anchored_ && f_.setPos(pos_);
        anchored_ = false;
        return ret;
    }
 
 
 
    ValType& val()
    {
        return v_;
    }
 
 
 
    const ValType& val() const
    {
        return v_;
    }
 
 
 
    operator const ValType&() const
    {
        return v_;
    }
 
 
 
    operator ValType&()
    {
        return v_;
    }
 
 
 
    const ValType& operator=(const ValType& rhs) const
    {
        v_ = rhs;
        return v_;
    }
 
 
 
    ValType& operator=(const ValType& rhs)
    {
        v_ = rhs;
        return v_;
    }
 
 
 
    const char* prefix() const
    {
        return prefix_ ? prefix_ : "";
    }
 
 
 
    const char* suffix() const
    {
        return suffix_ ? suffix_ : "";
    }
 
 
 
    PwpFile& f() const
    {
        return f_;
    }
 
 
 
    const sysFILEPOS& pos() const
    {
        return pos_;
    }
 
 
 
    PWP_INT fldWidth() const
    {
        return fldWidth_;
    }
 
 
 
    bool isAnchored() const
    {
        return anchored_;
    }
 
 
private:
 
    bool write()
    {
        bool ret = false;
        if (f_.isAscii()) {
            ret = ValWriter::writeAsc(!anchored_, f_, v_, fldWidth_, suffix_,
                prefix_);
        }
        else if (f_.isBinary()) {
            ret = ValWriter::writeBin(!anchored_, f_, v_, fldWidth_, suffix_,
                prefix_);
        }
        else if (f_.isUnformatted()) {
            ret = ValWriter::writeUnf(!anchored_, f_, v_, fldWidth_, suffix_,
                prefix_);
        }
        return ret;
    }
 
    PwpAnchoredFileValue<ValType,ValWriter> & operator=(
        const PwpAnchoredFileValue<ValType,ValWriter> & /*rhs*/)
    {
        return *this;
    }
 
 
private:
 
    bool            anchored_;
    ValType         v_;
    sysFILEPOS      pos_;
    const char *    suffix_;
    const char *    prefix_;
    PwpFile &       f_;
    PWP_INT         fldWidth_;
};
 
#endif  // _PWPANCHOREDFILEVALUE_H_