storageentrywrapper.java

lucene2.2.0版本

/** 
 * Copyright 2004 The Apache Software Foundation 
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); 
 * you may not use this file except in compliance with the License. 
 * You may obtain a copy of the License at 
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */

package org.apache.lucene.gdata.storage.lucenestorage;

import java.io.IOException;
import java.io.Serializable;
import java.io.StringWriter;

import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.gdata.data.ServerBaseEntry;
import org.apache.lucene.gdata.server.registry.ProvidedService;
import org.apache.lucene.gdata.server.registry.ProvidedServiceConfig;
import org.apache.lucene.gdata.storage.lucenestorage.StorageBuffer.BufferableEntry;

import com.google.gdata.data.BaseEntry;
import com.google.gdata.util.common.xml.XmlWriter;

/**
 * This immutable class wrapps <tt>ServerBaseEntry</tt> for an internal
 * Storage representation of an entry. This class also acts as a Documentfactory
 * for lucene documents to be stored inside the index.
 * 
 * @author Simon Willnauer
 * 
 */
public class StorageEntryWrapper implements Comparable<StorageEntryWrapper>, Serializable,
        StorageWrapper {

    private static final long serialVersionUID = -4619985652059888526L;
    /*
     * client api uses UTF-8 to encode server requests and entries
     */
    private static final String INTERNAL_ENCODING = "UTF-8";

    /**
     * lucene field name Entry id
     */
    public final static String FIELD_ENTRY_ID = "entryId";

    /**
     * lucene field name feed id
     */
    public final static String FIELD_FEED_REFERENCE = "feedReference";

    /**
     * lucene field name entry content
     */
    public final static String FIELD_CONTENT = "content";

    /**
     * lucene field name creating timestamp
     */
    public final static String FIELD_TIMESTAMP = "timestamp";

    /**
     * lucene field name entry version
     */
    public final static String FIELD_VERSION = "entryVersion";
    private  int version;

    private  String entryId;

    private  String feedId;

    private  String content;

    private transient ServerBaseEntry entry;

    private Long timestamp;

    private Document document;

    private StorageOperation operation;

    private transient ProvidedService config;

    /**
     * Creates a new StorageEntryWrapper.
     * 
     * @param entry -
     *            the entry to wrap
     * 
     * @param operation -
     *            the StorageOperation
     * 
     * @throws IOException -
     *             if the entry content can not be generated
     */
    public StorageEntryWrapper(final ServerBaseEntry entry,
            StorageOperation operation) throws IOException {
        this.entry = entry;
        this.operation = operation;
        this.entryId = entry.getId();
        this.feedId = entry.getFeedId();
        this.version = entry.getVersion();
        if (operation != StorageOperation.DELETE) {
            this.config = entry.getServiceConfig();
            this.content = buildContent();
            
         
        }
        this.timestamp = new Long(
                this.entry.getUpdated() != null ? this.entry.getUpdated()
                        .getValue() : System.currentTimeMillis());
            

    }
   
 
    private String buildContent() throws IOException {
        StringWriter writer = new StringWriter();
        XmlWriter xmlWriter = new XmlWriter(writer, INTERNAL_ENCODING);
        this.entry.generateAtom(xmlWriter, this.config.getExtensionProfile());
        return writer.toString();

    }

    /**
     * @see org.apache.lucene.gdata.storage.lucenestorage.StorageWrapper#getLuceneDocument()
     */
    public Document getLuceneDocument() {
        if(this.operation == StorageOperation.DELETE)
            return null;
        if (this.document != null)
            return this.document;
        this.document = new Document();
        this.document.add(new Field(FIELD_ENTRY_ID, this.entryId,
                Field.Store.YES, Field.Index.UN_TOKENIZED));
        this.document.add(new Field(FIELD_FEED_REFERENCE, this.feedId,
                Field.Store.YES, Field.Index.UN_TOKENIZED));
        this.document.add(new Field(FIELD_CONTENT,this.content,
                Field.Store.COMPRESS, Field.Index.NO));
        this.document.add(new Field(FIELD_TIMESTAMP, this.timestamp.toString(),
                Field.Store.YES, Field.Index.UN_TOKENIZED));
        this.document.add(new Field(FIELD_VERSION, Integer.toString(this.version),
                Field.Store.YES, Field.Index.UN_TOKENIZED));

        return this.document;

    }

    /**
     * @return - the wrapped entry
     */
    public BaseEntry getEntry() {
        /*
         * this wrapps the entry again. BufferableEntry creates a new instance
         * for the dynamic element like links.
         */
        return new BufferableEntry(this.entry.getEntry());
    }

    /**
     * @return - the entry id
     */
    public String getEntryId() {
        return this.entryId;
    }

    /**
     * @return - the feed id
     */
    public String getFeedId() {
        return this.feedId;
    }

    /**
     * Storage operations
     * 
     * @author Simon Willnauer
     * 
     */
    public static enum StorageOperation {
        /**
         * delete
         */
        DELETE,
        /**
         * update
         */
        UPDATE,
        /**
         * insert
         */
        INSERT
    }

    /**
     * @return the specified storage operation
     */
    public StorageOperation getOperation() {
        return this.operation;
    }

    /**
     * This compare method compares the timestamps of the wrapper instances.
     * 
     * @param arg0 -
     *            the wrapper to compare
     * @par
     * @return - 0 if the wrappers timestamp are the same, an integer > 0 if the
     *         given wrapper is after this wrapper
     * 
     */
    public int compareTo(StorageEntryWrapper arg0) {
        return arg0.timestamp.equals(this.timestamp) ? 0
                : (arg0.timestamp > this.timestamp ? 1 : -1);
    }

    /**
     * @return - the specified {@link ProvidedServiceConfig}
     */
    public ProvidedService getConfigurator() {
        return this.config;
    }

    /**
     * @return Returns the timestamp.
     */
    public Long getTimestamp() {
        return this.timestamp;
    }

    /**
     * @return - the version of the entry
     */
    public int getVersion() {
        
        return this.version;
    }



}