contentstorage.java

手机邮箱撒的方式方式方式的

/*
MujMail - Simple mail client for J2ME
Copyright (C) 2008 David Hauzar <[e-mail]>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, bufferContent to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
package mujmail;

import mujmail.util.Decode;
import mujmail.util.OutputBuffer;
import mujmail.protocols.MailSender;
import mujmail.connections.ConnectionInterface;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import mujmail.util.Functions;

/**
 * Persistently stores the content of body part. Part of 
 * <code>BodyPart</code>.
 *  
 * It is possible to incrementally add the content to existing
 * content without keeping existent content in heap memory. This is 
 * important for example when reading the content from SMTP connection.
 * 
 * Provides methods for adding content to the storage, for
 * buffered adding content to the storage - this case the content
 * is stored when more content for storing is collected - as well
 * as methods for reading or deleting the content.
 * Than provides information about the content contained in this
 * storage.   
 * 
 * Object of this type is contained in object {@link BodyPart}.
 * 
 * This object is stored persistently in RMS database. It's loading
 * and saving does object of instance {@link BodyPart} that
 * contains this storage.
 * 
 * @author David Hauzar
 */
public abstract class ContentStorage {
    /** Flag signals if we want to print debug prints */
    private static final boolean DEBUG = false;

    public static final String SOURCE_FILE = "ContentStorage";
    //private static final long MAX_SIZE_OF_BODYPART = Long.MAX_VALUE;

    private long size = 0;
    private BodyPart bodyPart;
    private final BufferedContentAdder buffer = new BufferedContentAdder();
    

    /**
     * 
     * @param bodyPart the body part which content is stored in this storage
     */
    protected ContentStorage(BodyPart bodyPart){
        this.bodyPart = bodyPart;
    }
    
    /**
     * Gets the name of the bodypart which content this storage holds.
     * @return the name of the bodypart that content this storage holds.
     */
    protected String getName() {
        return bodyPart.getHeader().getName();
    }

    /**
     * 
     * @param bodyPart the body part which content is stored in this storage
     * @param size the size of the content stored in the storage
     */
    protected ContentStorage(BodyPart bodyPart, long size) {
        this.bodyPart = bodyPart;
        this.size = size;
    }
    
    /**
     * It is important to lower the likelihood of throwing OutOfMemory exception
     * while calling method addToContent or addToContentRaw. This means that
     * allocating objects in these methods is undesirable. This method should
     * preallocate objects needed in addToContent or addToContentRaw.
     * 
     * It is ensured that this method will be called after saving the content 
     * to the storage and releasing the data kept in the buffer so it is
     * unlikely to OutOfMemoryException to be thrown there.
     */
    protected abstract void preallocateToNextSaving();
    
    /**
     * 
     * @return true if the content is yet preallocated to next saving.
     */
    protected abstract boolean preallocatedToNextSaving();
    
    /**
     * Ensures that te objects are really preallocated before calling addToContent
     * or addToContentRaw.
     */
    private void ensurePrealocating() {
        if (!preallocatedToNextSaving()) {
            preallocateToNextSaving();
        }
    }

    /**
     * Initialize class by copying another instance.
     * If copyMode is DEEP_COPY copies the content.
     * Note that if the mode is SHALLOW_COPY it the body part which content
     * will is stored in this ContentStorage should be in the same box as original
     * storage.
     * @param bp the body part which content is stored in this storage
     * @param copy AttachmentPart instance to copy
     * @param copyMode defines copying mode
     */
    protected ContentStorage(BodyPart bodyPart, ContentStorage copy, CopyingModes copyMode) {
        this.bodyPart = bodyPart;

        if (copyMode == CopyingModes.NO_COPY) {
            // the instance is yet created
            return;
        }

        if (copyMode == CopyingModes.DEEP_COPY) {
            addContent(copy, false);

            return;
        }
    }
    
    /**
     * Creates new instance of storage of type identified with given
     * number.
     * @param storageTypeNumber the number which identify the storage type
     *  of which we want to create an instance
     * @return the storage of given type
     */
    public static ContentStorage createStorageInstance(BodyPart bodyPart, byte storageTypeNumber) {
        //#ifdef MUJMAIL_FS
        if (storageTypeNumber == StorageTypes.FS_STORAGE.getStorageTypeNumber()) {
            return new FSStorage(bodyPart);
        }
        //#endif

        if (storageTypeNumber == StorageTypes.RMS_STORAGE.getStorageTypeNumber()) {
            return new RMSStorage(bodyPart);
        }

        throw new RuntimeException("not implemented storage type");
    }

    /**
     * Gets the body part which content is stored in the storage.
     * @return
     */
    protected BodyPart getBodyPart() { return bodyPart; }

    /**
     * Returns the storage type of given storage
     * @return
     */
    public abstract StorageTypes getStorageType();

    /**
     * Returns new instance of storage which is copy of this instance
     * of the storage.
     * @return new instance of storage which is copy of this instance
     */
    public abstract ContentStorage copy(BodyPart bp, CopyingModes copyMode);

    /**
     * Checks whether it is allowed to make a copy of this instance with given
     * copy mode.
     * @param bp
     * @param copyMode
     */
    protected boolean checkCopy(BodyPart bp, CopyingModes copyMode) {
        if (copyMode == CopyingModes.SHALLOW_COPY && bp.getBox() != getBodyPart().getBox()) {
            return false;
        }

        return true;
    }

    /**
     * Loads information about this storage from input stream (of RMS database).
     * Does not load the content of storage, loads only information about
     * the storage.
     * @param inputStream the input stream in which are stored information
     *  about this storage.
     * @throws java.lang.Exception can occur while reading inputStream
     */
    public void loadStorage(DataInputStream inputStream) throws Exception {
        setSize( inputStream.readLong() );
    }

    /**
     * Saves information about this storage to output stream (RMS database)
     * Does not save the content of the storage, saves only information about
     * this storage.
     * @param outputStream the output stream to which the information about
     *  this body part will be saved
     * @throws java.lang.Exception can occur while writing to the outputStream
     */
    public void saveStorageHeader(DataOutputStream outputStream) throws Exception {
        outputStream.writeLong(getSize());
    }

    /**
     * Deletes the content of this bodypart.
     */
    public void deleteContent() {
        setSize(0);
        buffer.clearCache();
        if (!bodyPart.convertedContentMode()) { 
            bodyPart.setBodyState(BodyPart.BS_EMPTY);
        }
        
        deleteContentFromStorage();
    }
    
    /**
     * Deletes the content from storage. Called from method 
     * {@link #deleteContent()}}.
     */
    protected abstract void deleteContentFromStorage();

    public void addContent(ContentStorage copy, boolean safeMode) {
        // TODO: redefine this method in class RMS storage
        // in case of RMS store it can be make too big records because 
        // getContent() or getContentRaw() returns not content from one record 
        // but from the maximum number of records that can be in RAM memory
        try {
            if (copy.isContentRaw()) {
               addToContentEnsurePreallocating(copy.getContentRaw(), safeMode);
               while (!copy.willReturnFirstContent()) {
                   addToContentEnsurePreallocating(copy.getContentRaw(), safeMode);
               }
            } else {
                addToContentEnsurePreallocating(copy.getContent(), safeMode);
                while (!copy.willReturnFirstContent()) {
                   addToContentEnsurePreallocating(copy.getContent(), safeMode);
                }
            }
        } catch (Throwable e) {
            getBodyPart().setBodyState(BodyPart.BS_EMPTY);
            size = 0;
            getBodyPart().getBox().report("+" + e.getMessage() + getBodyPart().getMessageHeader().getSubject(), SOURCE_FILE); //dont notice the user about the error
        }
    }
    
    protected String conditionallyAppend(String appendTo, String append, boolean shouldAppend) {
        if (shouldAppend) {
            return appendTo + append;
        } else {
            return appendTo;
        }
    }
    
    /**
     * According to the encoding and charset of the bodypart that content this
     * storage stores, decode given data.
     * @param data the data to be decoded
     * @return data decoded according to encoding and charset of the bodypart
     *  that stores this storage.
     * @throws mujmail.MyException
     */
    private String decodeNotRawBodypartData(String data) throws MyException {
        if (bodyPart.getHeader().getEncoding() == BodyPart.ENC_BASE64) {
            return Decode.decodeBase64(data, bodyPart.getHeader().getCharSet());
        } else if (bodyPart.getHeader().getEncoding() == BodyPart.ENC_QUOTEDPRINTABLE) {
            return Decode.decodeQuotedPrintable(data, bodyPart.getHeader().getCharSet());
        } else if (bodyPart.getHeader().getEncoding() == BodyPart.ENC_8BIT || bodyPart.getHeader().getCharSet() != BodyPart.CH_NORMAL) { //8bit or not usascii
            return Decode.decode8bitCharset(data, bodyPart.getHeader().getCharSet());
        } else { // 7- bit charset 	
            return data;
        }
    }
    
    /**
     * <p>
     * Adds given string to the storage.
     * Writes data not necessary immediately but only if bigger content for writing
     * is collected.
     * Note that it is necessary to call method {@link #flushBuffer()} to store data 
     * persistently before reading it.
     * </p>
     * <p>
     * Stores it according to encoding of the body part which content this storage
     * stores either as a raw data or as a text data.
     * </p>
     * @param bf the string which content store.
     */
    public void addToContentBuffered(String bf) throws Exception {
        buffer.bufferContent(bf);
    }
    
    /**
     * Adds given string to the storage.
     * Writes immediately.
     * 
     * Stores it according to encoding of the body part which content this storage
     * stores either as a raw data or as a text data.
     * @param bf the string which content store.
     */
    public void addToContent(String bf) throws Exception {
        addToContentBuffered(bf);
        flushBuffer();
        
    }
    
    /**
     * Stores data written in a buffer persistently. The data can be stored in
     * buffer when method addToContentBuffered is called.
     * @throws java.lang.Exception
     */
    public void flushBuffer() throws Exception {
        buffer.flush();
    }
    /**
     * Returns true if the content stored in this storage is raw data.
     * @return true if the content stored in this storage is raw data
     */
    public boolean isContentRaw() {
        if (getBodyPart().convertedContentMode()) {
            return true;
        } else {
            return (bodyPart.getHeader().getEncoding() == BodyPart.ENC_BASE64 && 
                    bodyPart.getHeader().getCharSet() == BodyPart.CH_NORMAL) ? 
                        true : 
                        false;
        }
    }

    /**
     * Adds given string to the content of the bodypart.
     * If passed content cannot be saved tries to shorten the content and
     * save it partially.
     *
     * This method neither sets the size of the bodypart nor the state of the
     * bodypart. This is done by methods inside class <code>ContentStorage<code/>
     * that calls this method.
     * 
     * This is a low-level method, saves bodypart always as a text data regardless
     * of the body part header. More high level method is addToContent(String).
     *
     * Before calling this method, method {@link #ensurePrealocating} is always
     * called.
     * 
     * @param content the content of the bodypart
     * @param safeMode if save mode is true, the content will be not saved
     *  to new persistent storage, but to temporary one
     * @return the size of content that was added to the content.
     *  content.length if all the content was written.
     */
    protected abstract long addToContent(String content, boolean safeMode) throws Exception;

    /**
     * Checks whether the size of bydypart with added content would be less or
     * equal than given limit.
     * If the size of bodypart with added content and the bodypart is not 
     * partially savebale. If it is partially saveable, sets its state to 
     * <code>BodyPart.BS_PARTIAL</code>. Than, it throws and exception.
     *
     * @param sizeOfAdded the size of added content to bodypart
     * @throws java.lang.Exception if the size of bodypart with added content
     *  is bigger than the limit.
     */
    /*
     * TODO: (David) this method is no more needed since the size of bodypart
     * is now checked while downloading the mail.
    private void checkSizeOfBodyPart(long sizeOfAdded) throws Exception {
        if (getSize() + sizeOfAdded > MAX_SIZE_OF_BODYPART) { 
            if (!MessageHeader.canBePartiallySaved(getBodyPart())) {
                deleteContent();
            } else {
                getBodyPart().setBodyState(BodyPart.BS_PARTIAL);
            }

            throw new Exception("The size of this bodypart is larger than given limit.");
        }
    }
     */

    /**