TnbCipherableFileAccessor.h

[詳解]

#pragma once
#include "TnbBytesCipher.h"
#include "TnbTemporaryAccessor.h"
#include "TnbFileName.h"
#include "TnbFile.h"
#include "TnbSerializeAdapter.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CCipherableFileAccessor : public CTemporaryAccessor
{
    DEFSUPER(CTemporaryAccessor);
    CStr            m_strFileName;      
    CStr            m_strHeadText;      
    CBytesCipher        m_cipher;       
 
    void m_Read(LPCTSTR lpszFile)
    {
        _super::DeleteAllSection();
        CVectorT<BYTE> vb;
        TNB::LoadCollection(lpszFile, m_strHeadText, vb);
        vb = m_cipher.Decode(vb);
        if ( ! vb.IsValid() )
        {
            throw CReadFailureException(ERROR_ACCESS_DENIED);
        }
        CDeserializeAdapter sr(&vb);
        sr >> CSerializeTag(_T("CiphFA"));
        sr >> _super::m_mapSec;
    }
 
    void m_Write(LPCTSTR lpszFile)
    {
        CVectorT<BYTE> vb;
        CSerializeAdapter sr(&vb);
        sr << CSerializeTag(_T("CiphFA"));
        sr << _super::m_mapSec;
        TNB::SaveCollection(lpszFile, m_strHeadText, m_cipher.Encode(vb));
    }
 
public:
    
    explicit CCipherableFileAccessor(LPCTSTR lpszFileName, LPCTSTR lpszHeadText, LPCTSTR lpszKey) : _super()
    {
        SetBase(lpszFileName, lpszHeadText, lpszKey);
    }
 
    void SetBase(LPCTSTR lpszFileName, LPCTSTR lpszHeadText, LPCTSTR lpszKey)
    {
        m_cipher.SetKey(lpszKey);
        m_cipher.Compression(true);
        m_strFileName = lpszFileName;
        m_strHeadText= lpszHeadText;
        CFileName fn = lpszFileName;
        if ( fn.IsExist() )
        {
            m_Read(fn);
        }
    }
 
    virtual CStr GetTypeName(void) const
    {
        return _T("CipherableFile");
    }
 
    virtual bool Flush(void)
    {
        CFileName fn = m_strFileName;
        try
        {
            m_Write(fn);
        }
        catch(CTnbException& e)
        {
            e.OnCatch();
            return false;
        }
        catch(...)
        {
            return false;
        }
        return true;
    }
};
 
 
 
inline ISerializer& operator<<(ISerializer& _sr, const IAccessor::CValue& t)
{
    DWORD dwKind = t.GetKind();
    _sr << dwKind;
    //
    switch ( dwKind )
    {
    case IAccessor::EK_Nothing:// 存在しない
        break;
    case IAccessor::EK_String:  // 文字列
        _sr << t.QueryString();
        break;
    case IAccessor::EK_PluralStrings:   // 複数の文字列群
        _sr << t.QueryPluralStrings();
        break;
    case IAccessor::EK_Binary:      // バイナリ
        _sr << t.QueryData();
        break;
    case IAccessor::EK_Dword:       // 32Bit Unsigned Integer
        _sr << t.QueryDword();
        break;
    case IAccessor::EK_Longlong:    // 64Bit Signed Integer
        _sr << t.QueryLonglong();
        break;
    default:
        ASSERTLIB(false);
        break;
    }
    return _sr;
}
 
inline const IDeserializer& operator>>(const IDeserializer& ds, IAccessor::CValue& _t)
{
    DWORD dwKind;
    ds >> dwKind;
    //
    switch ( dwKind )
    {
    case IAccessor::EK_Nothing:// 存在しない
        _t = IAccessor::CValue();
        break;
    case IAccessor::EK_String:  // 文字列
        {
            CStr s;
            ds >> s;
            _t = IAccessor::CValue(s);
        }
        break;
    case IAccessor::EK_PluralStrings:   // 複数の文字列群
        {
            CStrVector vs;
            ds >> vs;
            _t = IAccessor::CValue(vs);
        }
        break;
    case IAccessor::EK_Binary:      // バイナリ
        {
            CByteVector vb;
            ds >> vb;
            _t = IAccessor::CValue(vb);
        }
        break;
    case IAccessor::EK_Dword:       // 32Bit Unsigned Integer
        {
            DWORD dw;
            ds >> dw;
            _t = IAccessor::CValue(dw);
        }
        break;
    case IAccessor::EK_Longlong:        // 64Bit Signed Integer
        {
            LONGLONG ll;
            ds >> ll;
            _t = IAccessor::CValue(ll);
        }
        break;
    default:
        ASSERTLIB(false);
        _t = IAccessor::CValue();
        break;
    }
    return ds;
}
 
 
 
};//TNB