• Home
• com.mindoo.domino
• domino-jna
• 0.9.37
• source code
• NotesNote.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.mindoo.domino.jna.NotesNote Maven / Gradle / Ivy

package com.mindoo.domino.jna;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.StringWriter;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.BiConsumer;

import com.mindoo.domino.jna.NotesItem.ICompositeCallbackDirect;
import com.mindoo.domino.jna.NotesMIMEPart.PartType;
import com.mindoo.domino.jna.NotesNote.IItemCallback.Action;
import com.mindoo.domino.jna.constants.Compression;
import com.mindoo.domino.jna.constants.ItemType;
import com.mindoo.domino.jna.constants.MimePartOptions;
import com.mindoo.domino.jna.constants.NoteClass;
import com.mindoo.domino.jna.constants.OpenNote;
import com.mindoo.domino.jna.constants.UpdateNote;
import com.mindoo.domino.jna.errors.INotesErrorConstants;
import com.mindoo.domino.jna.errors.LotusScriptCompilationError;
import com.mindoo.domino.jna.errors.NotesError;
import com.mindoo.domino.jna.errors.NotesErrorUtils;
import com.mindoo.domino.jna.errors.UnsupportedItemValueError;
import com.mindoo.domino.jna.formula.FormulaExecution;
import com.mindoo.domino.jna.gc.IRecyclableNotesObject;
import com.mindoo.domino.jna.gc.NotesGC;
import com.mindoo.domino.jna.html.CommandId;
import com.mindoo.domino.jna.html.IHtmlApiReference;
import com.mindoo.domino.jna.html.IHtmlApiUrlTargetComponent;
import com.mindoo.domino.jna.html.IHtmlConversionResult;
import com.mindoo.domino.jna.html.IHtmlImageRef;
import com.mindoo.domino.jna.html.ReferenceType;
import com.mindoo.domino.jna.html.TargetType;
import com.mindoo.domino.jna.internal.CalNoteOpenData32;
import com.mindoo.domino.jna.internal.CalNoteOpenData64;
import com.mindoo.domino.jna.internal.CollationDecoder;
import com.mindoo.domino.jna.internal.CompoundTextWriter;
import com.mindoo.domino.jna.internal.DisposableMemory;
import com.mindoo.domino.jna.internal.ItemDecoder;
import com.mindoo.domino.jna.internal.Mem32;
import com.mindoo.domino.jna.internal.Mem64;
import com.mindoo.domino.jna.internal.NotesCallbacks;
import com.mindoo.domino.jna.internal.NotesConstants;
import com.mindoo.domino.jna.internal.NotesNativeAPI;
import com.mindoo.domino.jna.internal.NotesNativeAPI32;
import com.mindoo.domino.jna.internal.NotesNativeAPI64;
import com.mindoo.domino.jna.internal.ReadOnlyMemory;
import com.mindoo.domino.jna.internal.ViewFormatDecoder;
import com.mindoo.domino.jna.internal.Win32NotesCallbacks;
import com.mindoo.domino.jna.internal.structs.NoteIdStruct;
import com.mindoo.domino.jna.internal.structs.NotesBlockIdStruct;
import com.mindoo.domino.jna.internal.structs.NotesFileObjectStruct;
import com.mindoo.domino.jna.internal.structs.NotesLSCompileErrorInfoStruct;
import com.mindoo.domino.jna.internal.structs.NotesMIMEPartStruct;
import com.mindoo.domino.jna.internal.structs.NotesNumberPairStruct;
import com.mindoo.domino.jna.internal.structs.NotesObjectDescriptorStruct;
import com.mindoo.domino.jna.internal.structs.NotesOriginatorIdStruct;
import com.mindoo.domino.jna.internal.structs.NotesRangeStruct;
import com.mindoo.domino.jna.internal.structs.NotesTimeDatePairStruct;
import com.mindoo.domino.jna.internal.structs.NotesTimeDateStruct;
import com.mindoo.domino.jna.internal.structs.NotesUniversalNoteIdStruct;
import com.mindoo.domino.jna.internal.structs.compoundtext.NotesCDFieldStruct;
import com.mindoo.domino.jna.internal.structs.html.HTMLAPIReference32Struct;
import com.mindoo.domino.jna.internal.structs.html.HTMLAPIReference64Struct;
import com.mindoo.domino.jna.internal.structs.html.HtmlApi_UrlTargetComponentStruct;
import com.mindoo.domino.jna.mime.MimeConversionControl;
import com.mindoo.domino.jna.richtext.FieldInfo;
import com.mindoo.domino.jna.richtext.ICompoundText;
import com.mindoo.domino.jna.richtext.IRichTextNavigator;
import com.mindoo.domino.jna.richtext.IRichTextNavigator.RichTextNavPosition;
import com.mindoo.domino.jna.richtext.RichTextBuilder;
import com.mindoo.domino.jna.richtext.StandaloneRichText;
import com.mindoo.domino.jna.richtext.conversion.IRichTextConversion;
import com.mindoo.domino.jna.utils.IDUtils;
import com.mindoo.domino.jna.utils.LegacyAPIUtils;
import com.mindoo.domino.jna.utils.ListUtil;
import com.mindoo.domino.jna.utils.Loop;
import com.mindoo.domino.jna.utils.NotesDateTimeUtils;
import com.mindoo.domino.jna.utils.NotesNamingUtils;
import com.mindoo.domino.jna.utils.NotesStringUtils;
import com.mindoo.domino.jna.utils.PlatformUtils;
import com.mindoo.domino.jna.utils.Ref;
import com.mindoo.domino.jna.utils.StringUtil;
import com.sun.jna.Memory;
import com.sun.jna.Native;
import com.sun.jna.Pointer;
import com.sun.jna.StringArray;
import com.sun.jna.ptr.ByteByReference;
import com.sun.jna.ptr.DoubleByReference;
import com.sun.jna.ptr.IntByReference;
import com.sun.jna.ptr.LongByReference;
import com.sun.jna.ptr.PointerByReference;
import com.sun.jna.ptr.ShortByReference;

import lotus.domino.Database;
import lotus.domino.Document;
import lotus.domino.NotesException;

/**
 * Object wrapping a Notes document / note
 * 
 * @author Karsten Lehmann
 */
public class NotesNote implements IRecyclableNotesObject {
	private int m_hNote32;
	private long m_hNote64;
	private boolean m_noRecycle;
	private NotesDatabase m_parentDb;
	private Document m_legacyDocRef;
	private EnumSet m_noteClass;
	private boolean m_preferNotesTimeDates;
	
	/**
	 * Creates a new instance
	 * 
	 * @param parentDb parent database
	 * @param hNote handle
	 */
	NotesNote(NotesDatabase parentDb, int hNote) {
		if (PlatformUtils.is64Bit())
			throw new IllegalStateException("Constructor is 32bit only");
		m_parentDb = parentDb;
		m_hNote32 = hNote;
	}

	/**
	 * Creates a new instance
	 * 
	 * @param parentDb parent database
	 * @param hNote handle
	 */
	NotesNote(NotesDatabase parentDb, long hNote) {
		if (!PlatformUtils.is64Bit())
			throw new IllegalStateException("Constructor is 64bit only");
		m_parentDb = parentDb;
		m_hNote64 = hNote;
	}

	/**
	 * Creates a new NotesNote
	 * 
	 * @param adaptable adaptable providing enough information to create the database
	 */
	public NotesNote(IAdaptable adaptable) {
		Document legacyDoc = adaptable.getAdapter(Document.class);
		if (legacyDoc!=null) {
			if (isRecycled(legacyDoc))
				throw new NotesError(0, "Legacy database already recycled");
			
			long docHandle = LegacyAPIUtils.getDocHandle(legacyDoc);
			if (docHandle==0)
				throw new NotesError(0, "Could not read db handle");
			
			if (PlatformUtils.is64Bit()) {
				m_hNote64 = docHandle;
			}
			else {
				m_hNote32 = (int) docHandle;
			}
			setNoRecycle();
			m_legacyDocRef = legacyDoc;
			
			Database legacyDb;
			try {
				legacyDb = legacyDoc.getParentDatabase();
			} catch (NotesException e1) {
				throw new NotesError(0, "Could not read parent legacy db from document", e1);
			}
			long dbHandle = LegacyAPIUtils.getDBHandle(legacyDb);
			try {
				if (PlatformUtils.is64Bit()) {
					m_parentDb = (NotesDatabase) NotesGC.__b64_checkValidObjectHandle(NotesDatabase.class, dbHandle);
				}
				else {
					m_parentDb = (NotesDatabase) NotesGC.__b32_checkValidObjectHandle(NotesDatabase.class, (int) dbHandle);
				}
			} catch (NotesError e) {
				m_parentDb = LegacyAPIUtils.toNotesDatabase(legacyDb);
			}
			return;
		}
		if (PlatformUtils.is64Bit()) {
			CalNoteOpenData64 calOpenNote = adaptable.getAdapter(CalNoteOpenData64.class);
			if (calOpenNote!=null) {
				m_parentDb = calOpenNote.getDb();
				m_hNote64 = calOpenNote.getNoteHandle();
				return;
			}
		}
		else {
			CalNoteOpenData32 calOpenNote = adaptable.getAdapter(CalNoteOpenData32.class);
			if (calOpenNote!=null) {
				m_parentDb = calOpenNote.getDb();
				m_hNote32 = calOpenNote.getNoteHandle();
				return;
			}
		}
		throw new NotesError(0, "Unsupported adaptable parameter");
	}

	private boolean isRecycled(Document doc) {
		try {
			//call any method to check recycled state
			doc.hasItem("~-~-~-~-~-~");
		}
		catch (NotesException e) {
			if (e.id==4376 || e.id==4466)
				return true;
		}
		return false;
	}

	/**
	 * Converts a legacy {@link lotus.domino.Document} to a
	 * {@link NotesNote}.
	 * 
	 * @param doc document to convert
	 * @return note
	 */
	public static NotesNote toNote(final Document doc) {
		return LegacyAPIUtils.toNotesNote(doc);
	}
	
	/**
	 * Converts this note to a legacy {@link Document}
	 * 
	 * @param db parent database
	 * @return document
	 */
	public Document toDocument(Database db) {
		if (PlatformUtils.is64Bit()) {
			return LegacyAPIUtils.createDocument(db, m_hNote64);
		}
		else {
			return LegacyAPIUtils.createDocument(db, m_hNote32);
		}
	}
	
	/**
	 * Returns the parent database
	 * 
	 * @return database
	 */
	public NotesDatabase getParent() {
		return m_parentDb;
	}
	
	/**
	 * Returns the note id of the note
	 * 
	 * @return note id
	 */
	public int getNoteId() {
		checkHandle();
		
		Memory retNoteId = new Memory(4);
		retNoteId.clear();
		
		if (PlatformUtils.is64Bit()) {
			NotesNativeAPI64.get().NSFNoteGetInfo(m_hNote64, NotesConstants._NOTE_ID, retNoteId);
		}
		else {
			NotesNativeAPI32.get().NSFNoteGetInfo(m_hNote32, NotesConstants._NOTE_ID, retNoteId);
		}
		return retNoteId.getInt(0);
	}
	
	/**
	 * Method to check whether a note has already been saved
	 * 
	 * @return true if yet unsaved
	 */
	public boolean isNewNote() {
		return getNoteId() == 0;
	}
	
	/**
	 * Returns the note class of the note
	 * 
	 * @return note class
	 */
	public EnumSet getNoteClass() {
		if (m_noteClass==null) {
			checkHandle();
			
			Memory retNoteClass = new Memory(2);
			retNoteClass.clear();
			
			if (PlatformUtils.is64Bit()) {
				NotesNativeAPI64.get().NSFNoteGetInfo(m_hNote64, NotesConstants._NOTE_CLASS, retNoteClass);
			}
			else {
				NotesNativeAPI32.get().NSFNoteGetInfo(m_hNote32, NotesConstants._NOTE_CLASS, retNoteClass);
			}
			int noteClassMask = retNoteClass.getShort(0);
			m_noteClass = NoteClass.toNoteClasses(noteClassMask);
		}
		return m_noteClass;
	}
	
	/**
	 * Changes the note class for this note
	 * 
	 * @param noteClass new note class
	 */
	public void setNoteClass(EnumSet noteClass) {
		checkHandle();

		EnumSet noteClassToWrite = noteClass.clone();
		noteClassToWrite.remove(NoteClass.ALL);
		noteClassToWrite.remove(NoteClass.ALLNONDATA);
		
		short noteClassToWriteAsShort = NoteClass.toBitMask(noteClassToWrite);
		
		DisposableMemory noteClassMem = new DisposableMemory(2);
		noteClassMem.setShort(0, noteClassToWriteAsShort);
		
		try {
			if (PlatformUtils.is64Bit()) {
				NotesNativeAPI64.get().NSFNoteSetInfo(m_hNote64, NotesConstants._NOTE_CLASS, noteClassMem);
			}
			else {
				NotesNativeAPI32.get().NSFNoteSetInfo(m_hNote32, NotesConstants._NOTE_CLASS, noteClassMem);
			}
		}
		finally {
			noteClassMem.dispose();
		}
	}
	
	/**
	 * Converts the value of {@link #getNoteId()} to a hex string in uppercase
	 * format
	 * 
	 * @return note id as hex string
	 */
	public String getNoteIdAsString() {
		return Integer.toString(getNoteId(), 16).toUpperCase();
	}
	
	@Override
	public String toString() {
		if (isRecycled()) {
			return "NotesNote [recycled]";
		}
		else {
			return "NotesNote [handle="+(PlatformUtils.is64Bit() ? m_hNote64 : m_hNote32)+", noteid="+getNoteId()+"]";
		}
	}
	
	/**
	 * Returns the UNID of the note
	 * 
	 * @return UNID
	 */
	public String getUNID() {
		NotesOriginatorIdStruct oid = getOIDStruct();
		String unid = oid.getUNIDAsString();
		return unid;
	}

	/**
	 * Internal method to get the populated {@link NotesOriginatorIdStruct} object
	 * for this note
	 * 
	 * @return oid structure
	 */
	private NotesOriginatorIdStruct getOIDStruct() {
		checkHandle();
		
		Memory retOid = new Memory(NotesConstants.oidSize);
		retOid.clear();
		
		if (PlatformUtils.is64Bit()) {
			NotesNativeAPI64.get().NSFNoteGetInfo(m_hNote64, NotesConstants._NOTE_OID, retOid);
		}
		else {
			NotesNativeAPI32.get().NSFNoteGetInfo(m_hNote32, NotesConstants._NOTE_OID, retOid);
		}
		NotesOriginatorIdStruct oidStruct = NotesOriginatorIdStruct.newInstance(retOid);
		oidStruct.read();
		
		return oidStruct;
	}
	
	/**
	 * Returns the {@link NotesOriginatorId} for this note
	 * 
	 * @return oid
	 */
	public NotesOriginatorId getOID() {
		NotesOriginatorIdStruct oidStruct = getOIDStruct();
		NotesOriginatorId oid = new NotesOriginatorId(oidStruct);
		return oid;
	}
	
	/**
	 * Sets a new UNID in the {@link NotesOriginatorId} for this note
	 * 
	 * @param newUnid new universal id
	 */
	public void setUNID(String newUnid) {
		checkHandle();

		DisposableMemory retOid = new DisposableMemory(NotesConstants.oidSize);
		try {
			retOid.clear();

			if (PlatformUtils.is64Bit()) {
				NotesNativeAPI64.get().NSFNoteGetInfo(m_hNote64, NotesConstants._NOTE_OID, retOid);
			}
			else {
				NotesNativeAPI32.get().NSFNoteGetInfo(m_hNote32, NotesConstants._NOTE_OID, retOid);
			}
			NotesOriginatorIdStruct oidStruct = NotesOriginatorIdStruct.newInstance(retOid);
			oidStruct.read();
			oidStruct.setUNID(newUnid);
			if (PlatformUtils.is64Bit()) {
				NotesNativeAPI64.get().NSFNoteSetInfo(m_hNote64, NotesConstants._NOTE_OID, retOid);
			}
			else {
				NotesNativeAPI32.get().NSFNoteSetInfo(m_hNote32, NotesConstants._NOTE_OID, retOid);
			}
		}
		finally {
			retOid.dispose();
		}
	}
	
	/**
	 * Returns the last modified date of the note
	 * 
	 * @return last modified date
	 */
	public Calendar getLastModified() {
		NotesTimeDate td = getLastModifiedAsTimeDate();
		return td==null ? null : td.toCalendar();
	}

	/**
	 * Returns the last modified date of the note
	 * 
	 * @return last modified date as {@link NotesTimeDate}
	 */
	public NotesTimeDate getLastModifiedAsTimeDate() {
		checkHandle();

		DisposableMemory retModified = new DisposableMemory(NotesConstants.timeDateSize);
		try {
			retModified.clear();

			if (PlatformUtils.is64Bit()) {
				NotesNativeAPI64.get().NSFNoteGetInfo(m_hNote64, NotesConstants._NOTE_MODIFIED, retModified);
			}
			else {
				NotesNativeAPI32.get().NSFNoteGetInfo(m_hNote32, NotesConstants._NOTE_MODIFIED, retModified);
			}
			NotesTimeDateStruct td = NotesTimeDateStruct.newInstance(retModified);
			td.read();
			return new NotesTimeDate(td.Innards);
		}
		finally {
			retModified.dispose();
		}
	}
	
	/**
	 * Returns the creation date of this note
	 * 
	 * @return creation date
	 */
	public Calendar getCreationDate() {
		checkHandle();
		
		Calendar creationDate = getItemValueDateTime("$CREATED");
		if (creationDate!=null) {
			return creationDate;
		}
		
		NotesOriginatorIdStruct oidStruct = getOIDStruct();
		NotesTimeDateStruct creationDateStruct = oidStruct.Note;
		return creationDateStruct.toCalendar();
	}
	
	/**
	 * Returns the creation date of this note
	 * 
	 * @return creation date as {@link NotesTimeDate}
	 */
	public NotesTimeDate getCreationDateAsTimeDate() {
		checkHandle();
		
		NotesTimeDate creationDate = getItemValueAsTimeDate("$CREATED");
		if (creationDate!=null) {
			return creationDate;
		}
		
		NotesOriginatorIdStruct oidStruct = getOIDStruct();
		NotesTimeDateStruct creationDateStruct = oidStruct.Note;
		return new NotesTimeDate(creationDateStruct.Innards);
	}
	
	/**
	 * Returns the last access date of the note
	 * 
	 * @return last access date
	 */
	public Calendar getLastAccessed() {
		checkHandle();
		
		DisposableMemory retAccessed = new DisposableMemory(NotesConstants.timeDateSize);
		try {
			retAccessed.clear();

			if (PlatformUtils.is64Bit()) {
				NotesNativeAPI64.get().NSFNoteGetInfo(m_hNote64, NotesConstants._NOTE_ACCESSED, retAccessed);
			}
			else {
				NotesNativeAPI32.get().NSFNoteGetInfo(m_hNote32, NotesConstants._NOTE_ACCESSED, retAccessed);
			}
			NotesTimeDateStruct td = NotesTimeDateStruct.newInstance(retAccessed);
			td.read();
			Calendar cal = td.toCalendar();
			return cal;
		}
		finally {
			retAccessed.dispose();
		}
	}

	/**
	 * Returns the last access date of the note
	 * 
	 * @return last access date as {@link NotesTimeDate}
	 */
	public NotesTimeDate getLastAccessedAsTimeDate() {
		checkHandle();
		
		DisposableMemory retAccessed = new DisposableMemory(NotesConstants.timeDateSize);
		try {
			retAccessed.clear();

			if (PlatformUtils.is64Bit()) {
				NotesNativeAPI64.get().NSFNoteGetInfo(m_hNote64, NotesConstants._NOTE_ACCESSED, retAccessed);
			}
			else {
				NotesNativeAPI32.get().NSFNoteGetInfo(m_hNote32, NotesConstants._NOTE_ACCESSED, retAccessed);
			}
			NotesTimeDateStruct td = NotesTimeDateStruct.newInstance(retAccessed);
			td.read();
			return new NotesTimeDate(td.Innards);
		}
		finally {
			retAccessed.dispose();
		}
	}
	
	/**
	 * Returns the date/time when the note got added to the NSF instance
	 * 
	 * @return added to file time
	 */
	public Calendar getAddedToFileTime() {
		checkHandle();
		
		Memory retAddedToFile = new Memory(NotesConstants.timeDateSize);
		retAddedToFile.clear();
		
		if (PlatformUtils.is64Bit()) {
			NotesNativeAPI64.get().NSFNoteGetInfo(m_hNote64, NotesConstants._NOTE_ADDED_TO_FILE, retAddedToFile);
		}
		else {
			NotesNativeAPI32.get().NSFNoteGetInfo(m_hNote32, NotesConstants._NOTE_ADDED_TO_FILE, retAddedToFile);
		}
		NotesTimeDateStruct td = NotesTimeDateStruct.newInstance(retAddedToFile);
		td.read();
		Calendar cal = td.toCalendar();
		return cal;
	}

	/**
	 * Returns the date/time when the note got added to the NSF instance
	 * 
	 * @return added to file time as {@link NotesTimeDate}
	 */
	public NotesTimeDate getAddedToFileTimeAsTimeDate() {
		checkHandle();
		
		DisposableMemory retAddedToFile = new DisposableMemory(NotesConstants.timeDateSize);
		try {
			retAddedToFile.clear();

			if (PlatformUtils.is64Bit()) {
				NotesNativeAPI64.get().NSFNoteGetInfo(m_hNote64, NotesConstants._NOTE_ADDED_TO_FILE, retAddedToFile);
			}
			else {
				NotesNativeAPI32.get().NSFNoteGetInfo(m_hNote32, NotesConstants._NOTE_ADDED_TO_FILE, retAddedToFile);
			}
			NotesTimeDateStruct td = NotesTimeDateStruct.newInstance(retAddedToFile);
			td.read();
			return new NotesTimeDate(td.Innards);
		}
		finally {
			retAddedToFile.dispose();
		}
	}
	
	/**
	 * The NOTE_FLAG_READONLY bit indicates that the note is Read-Only for the current user.

	 * If a note contains an author names field, and the name of the user opening the
	 * document is not included in the author names field list, then  the NOTE_FLAG_READONLY
	 * bit is set in the note header data when that user opens the note.
	 * 
	 * @return TRUE if document cannot be updated
	 */
	public boolean isReadOnly() {
		int flags = getFlags();
		return (flags & NotesConstants.NOTE_FLAG_READONLY) == NotesConstants.NOTE_FLAG_READONLY;
	}
	
	/**
	 * The NOTE_FLAG_ABSTRACTED bit indicates that the note has been abstracted (truncated).

	 * This bit may be set if the database containing the note has replication settings set to
	 * "Truncate large documents and remove attachments".
	 * 
	 * @return true if truncated
	 */
	public boolean isTruncated() {
		int flags = getFlags();
		return (flags & NotesConstants.NOTE_FLAG_ABSTRACTED) == NotesConstants.NOTE_FLAG_ABSTRACTED;
	}

	/**
	 * Method to check if this is ghost note. Ghost notes do not appear in any view or search.
	 * 
	 * @return true if ghost
	 */
	public boolean isGhost() {
		int flags = getFlags();
		return (flags & NotesConstants.NOTE_FLAG_GHOST) == NotesConstants.NOTE_FLAG_GHOST;
	}
	
	/**
	 * Changes the note's ghost flag. Ghost notes do not appear in any view or search.
	 * 
	 * @param b true if ghost
	 */
	void setGhost(boolean b) {
		short flags = getFlags();
		short newFlags;
		
		if (b) {
			if ((flags & NotesConstants.NOTE_FLAG_GHOST) == NotesConstants.NOTE_FLAG_GHOST) {
				return;
			}
			
			newFlags = (short) ((flags | NotesConstants.NOTE_FLAG_GHOST) & 0xffff);
		}
		else {
			if ((flags & NotesConstants.NOTE_FLAG_GHOST) == 0) {
				return;
			}
			
			newFlags = (short) ((flags & ~NotesConstants.NOTE_FLAG_GHOST) & 0xffff);
		}
		
		setFlags(newFlags);
	}
	
	/**
	 * Examines the items in the note and determines if they are correctly formed.
	 * 
	 * @throws NotesError if items contain errors like the overall lengths does not match the data type ({@link INotesErrorConstants#ERR_INVALID_ITEMLEN}) or an item's type is not recognized ({@link INotesErrorConstants#ERR_INVALID_ITEMTYPE})
	 */
	public void check() {
		checkHandle();

		short result;
		if (PlatformUtils.is64Bit()) {
			result = NotesNativeAPI64.get().NSFNoteCheck(getHandle64());
		} else {
			result = NotesNativeAPI32.get().NSFNoteCheck(getHandle32());
		}
		NotesErrorUtils.checkResult(result);
	}
	
	/**
	 * Reads the note flags (e.g. {@link NotesConstants#NOTE_FLAG_READONLY})
	 * 
	 * @return flags
	 */
	private short getFlags() {
		checkHandle();

		DisposableMemory retFlags = new DisposableMemory(2);
		try {
			retFlags.clear();

			if (PlatformUtils.is64Bit()) {
				NotesNativeAPI64.get().NSFNoteGetInfo(m_hNote64, NotesConstants._NOTE_FLAGS, retFlags);
			}
			else {
				NotesNativeAPI32.get().NSFNoteGetInfo(m_hNote32, NotesConstants._NOTE_FLAGS, retFlags);
			}
			short flags = retFlags.getShort(0);
			return flags;
		}
		finally {
			retFlags.dispose();
		}
	}
	
	private void setFlags(short flags) {
		checkHandle();

		DisposableMemory flagsMem = new DisposableMemory(2);
		try {
			flagsMem.setShort(0, flags);

			if (PlatformUtils.is64Bit()) {
				NotesNativeAPI64.get().NSFNoteSetInfo(m_hNote64, NotesConstants._NOTE_FLAGS, flagsMem);
			}
			else {
				NotesNativeAPI32.get().NSFNoteSetInfo(m_hNote32, NotesConstants._NOTE_FLAGS, flagsMem);
			}
		}
		finally {
			flagsMem.dispose();
		}
	}
	
	public void setNoRecycle() {
		m_noRecycle=true;
	}
	
	@Override
	public boolean isNoRecycle() {
		return m_noRecycle;
	}
	
	@Override
	public void recycle() {
		if (m_noRecycle || isRecycled())
			return;

		short result;
		if (PlatformUtils.is64Bit()) {
			result = NotesNativeAPI64.get().NSFNoteClose(m_hNote64);
			NotesErrorUtils.checkResult(result);
			NotesGC.__objectBeeingBeRecycled(NotesNote.class, this);
			m_hNote64=0;
			
			DisposableMemory retStrBufMem = stringretBuffer.get();
			if (retStrBufMem!=null) {
				if (!retStrBufMem.isDisposed()) {
					retStrBufMem.dispose();
				}
				stringretBuffer.set(null);
			}
		}
		else {
			result = NotesNativeAPI32.get().NSFNoteClose(m_hNote32);
			NotesErrorUtils.checkResult(result);
			NotesGC.__objectBeeingBeRecycled(NotesNote.class, this);
			m_hNote32=0;
			
			DisposableMemory retStrBufMem = stringretBuffer.get();
			if (retStrBufMem!=null) {
				if (!retStrBufMem.isDisposed()) {
					retStrBufMem.dispose();
				}
				stringretBuffer.set(null);
			}
		}
	}

	@Override
	public boolean isRecycled() {
		if (m_legacyDocRef!=null && isRecycled(m_legacyDocRef)) {
			return true;
		}

		if (PlatformUtils.is64Bit()) {
			return m_hNote64==0;
		}
		else {
			return m_hNote32==0;
		}
	}

	@Override
	public int getHandle32() {
		return m_hNote32;
	}

	@Override
	public long getHandle64() {
		return m_hNote64;
	}

	void checkHandle() {
		if (m_legacyDocRef!=null) {
			if (isRecycled(m_legacyDocRef)) {
				throw new NotesError(0, "Wrapped legacy document already recycled");
			}
			else {
				//note not registered in our GC, so skip the following handle check
				return;
			}
		}
		
		if (PlatformUtils.is64Bit()) {
			if (m_hNote64==0)
				throw new NotesError(0, "Note already recycled");
			NotesGC.__b64_checkValidObjectHandle(NotesNote.class, m_hNote64);
		}
		else {
			if (m_hNote32==0)
				throw new NotesError(0, "Note already recycled");
			NotesGC.__b32_checkValidObjectHandle(NotesNote.class, m_hNote32);
		}
	}

	/**
	 * Unsigns the note. This function removes the $Signature item from the note.
	 */
	public void unsign() {
		checkHandle();
		
		if (PlatformUtils.is64Bit()) {
			short result = NotesNativeAPI64.get().NSFNoteUnsign(m_hNote64);
			NotesErrorUtils.checkResult(result);
		}
		else {
			short result = NotesNativeAPI32.get().NSFNoteUnsign(m_hNote32);
			NotesErrorUtils.checkResult(result);
		}
	}
	
	/**
	 * This function writes the in-memory version of a note to its database.

	 * 

	 * Prior to issuing this call, a new note (or changes to a note) are not a part
	 * of the on-disk database.

	 * 

	 * This function allows using extended 32-bit DWORD update options, as described
	 * in the entry {@link UpdateNote}.

	 * 

	 * You should also consider updating the collections associated with other Views
	 * in a database via the function {@link NotesCollection#update()},
	 * if you have added and/or deleted a substantial number of documents.

	 * 

	 * If the Server's Indexer Task does not rebuild the collections associated with the database's Views,
	 * the first user to access a View in the modified database might experience an inordinant
	 * delay, while the collection is rebuilt by the Notes Workstation (locally) or
	 * Server Application (remotely).

	 * @param updateFlags flags
	 */
	public void update(EnumSet updateFlags) {
		if (checkForProfileAndUpdate()) {
			return;
		}
		checkHandle();
		
		int updateFlagsBitmask = UpdateNote.toBitMaskForUpdateExt(updateFlags);
		
		if (PlatformUtils.is64Bit()) {
			short result = NotesNativeAPI64.get().NSFNoteUpdateExtended(m_hNote64, updateFlagsBitmask);
			NotesErrorUtils.checkResult(result);
		}
		else {
			short result = NotesNativeAPI32.get().NSFNoteUpdateExtended(m_hNote32, updateFlagsBitmask);
			NotesErrorUtils.checkResult(result);
		}
	}

	/**
	 * Checks if this note is a profile. If it is, we use a different C method
	 * to update it in the database and also update the profile cache.
	 * 
	 * @return true if note is a profile note that has been saved, false otherwise
	 */
	private boolean checkForProfileAndUpdate() {
		checkHandle();
		
		if (!isGhost()) {
			return false;
		}
		
		String[] profileNameAndUsername = parseProfileAndUserName();
		
		if (profileNameAndUsername==null) {
			return false;
		}
		String profileName = profileNameAndUsername[0];
		String profileUsername = profileNameAndUsername[1];
		
		Memory profileNameMem = NotesStringUtils.toLMBCS(profileName, false);
		Memory userNameMem = StringUtil.isEmpty(profileUsername) ? null : NotesStringUtils.toLMBCS(profileUsername, false);

		//NSFProfileUpdate updates the profile cache
		short result;
		if (PlatformUtils.is64Bit()) {
			result = NotesNativeAPI64.get().NSFProfileUpdate(getHandle64(),
					profileNameMem, (short) (profileNameMem.size() & 0xffff), userNameMem,
					(short) (userNameMem==null ? 0 : (userNameMem.size() & 0xffff)));
		}
		else {
			result = NotesNativeAPI32.get().NSFProfileUpdate(getHandle32(),
					profileNameMem, (short) (profileNameMem.size() & 0xffff), userNameMem,
					(short) (userNameMem==null ? 0 : (userNameMem.size() & 0xffff)));
		}
		NotesErrorUtils.checkResult(result);

		return true;
	}
	
	/**
	 * This function writes the in-memory version of a note to its database.

	 * Prior to issuing this call, a new note (or changes to a note) are not a part of
	 * the on-disk database.

	 * 

	 * You should also consider updating the collections associated with other Views in a database
	 * via the function
	 * {@link NotesCollection#update()}, if you have added and/or deleted a substantial number of documents.

	 * If the Server's Indexer Task does not rebuild the collections associated with
	 * the database's Views, the first user to access a View in the modified database
	 * might experience an inordinant delay, while the collection is rebuilt by the
	 * Notes Workstation (locally) or Server Application (remotely).

	 * 

	 * Do not update notes to disk that contain invalid items.

	 * An example of an invalid item is a view design note that has a $Collation item
	 * whose BufferSize member is set to zero.

	 * This update method may return an error for an invalid item that was not caught
	 * in a previous release of Domino or Notes.

	 * Note: if you have enabled IMAP on a database, in the case of the
	 * special NoteID "NOTEID_ADD_OR_REPLACE", a new note is always created.
	 * 
	 */
	public void update() {
		update(EnumSet.noneOf(UpdateNote.class));
	}

	/**
	 * The method checks whether an item exists
	 * 
	 * @param itemName item name
	 * @return true if the item exists
	 */
	public boolean hasItem(String itemName) {
		checkHandle();
		
		Memory itemNameMem = NotesStringUtils.toLMBCS(itemName, false);

		short result;
		if (PlatformUtils.is64Bit()) {
			result = NotesNativeAPI64.get().NSFItemInfo(m_hNote64, itemNameMem, (short) (itemNameMem.size() & 0xffff), null, null, null, null);
		}
		else {
			result = NotesNativeAPI32.get().NSFItemInfo(m_hNote32, itemNameMem, (short) (itemNameMem.size() & 0xffff), null, null, null, null);
		}
		return result == 0;	
	}
	
	/**
	 * The function NSFNoteHasComposite returns TRUE if the given note contains any TYPE_COMPOSITE items.
	 * 
	 * @return true if composite
	 */
	public boolean hasComposite() {
		checkHandle();
		
		if (PlatformUtils.is64Bit()) {
			return NotesNativeAPI64.get().NSFNoteHasComposite(m_hNote64) == 1;
		}
		else {
			return NotesNativeAPI32.get().NSFNoteHasComposite(m_hNote32) == 1;
		}
	}
	
	/**
	 * The function NSFNoteHasMIME returns TRUE if the given note contains either {@link NotesItem#TYPE_RFC822_TEXT}
	 * items or {@link NotesItem#TYPE_MIME_PART} items.
	 * 
	 * @return true if mime
	 */
	public boolean hasMIME() {
		checkHandle();
		
		if (PlatformUtils.is64Bit()) {
			return NotesNativeAPI64.get().NSFNoteHasMIME(m_hNote64) == 1;
		}
		else {
			return NotesNativeAPI32.get().NSFNoteHasMIME(m_hNote32) == 1;
		}
	}
	
	/**
	 * The function returns TRUE if the given note contains any {@link NotesItem#TYPE_MIME_PART} items.
	 * 
	 * @return true if mime part
	 */
	public boolean hasMIMEPart() {
		checkHandle();
		
		if (PlatformUtils.is64Bit()) {
			return NotesNativeAPI64.get().NSFNoteHasMIMEPart(m_hNote64) == 1;
		}
		else {
			return NotesNativeAPI32.get().NSFNoteHasMIMEPart(m_hNote32) == 1;
		}
	}
	
	/**
	 * The function returns TRUE if the given note contains any items with reader access flag
	 * 
	 * @return true if readers field
	 */
	public boolean hasReadersField() {
		checkHandle();
		
		NotesBlockIdStruct blockId = NotesBlockIdStruct.newInstance();
		boolean hasReaders;
		
		//use an optimized call to search for reader fields
		if (PlatformUtils.is64Bit()) {
			hasReaders = NotesNativeAPI64.get().NSFNoteHasReadersField(m_hNote64, blockId) == 1;
		}
		else {
			hasReaders = NotesNativeAPI32.get().NSFNoteHasReadersField(m_hNote32, blockId) == 1;
		}
		
		return hasReaders;
	}
	
	/**
	 * The function returns all the readers items of the note
	 * 
	 * @return array with readers fields
	 */
	public List getReadersFields() {
		checkHandle();
		
		NotesBlockIdStruct blockId = NotesBlockIdStruct.newInstance();
		boolean hasReaders;
		
		//use an optimized call to find the first readers field
		if (PlatformUtils.is64Bit()) {
			hasReaders = NotesNativeAPI64.get().NSFNoteHasReadersField(m_hNote64, blockId) == 1;
		}
		else {
			hasReaders = NotesNativeAPI32.get().NSFNoteHasReadersField(m_hNote32, blockId) == 1;
		}
		
		if (!hasReaders)
			return Collections.emptyList();
		
		List readerFields = new ArrayList();
		
		NotesBlockIdStruct.ByValue itemBlockIdByVal = NotesBlockIdStruct.ByValue.newInstance();
		itemBlockIdByVal.pool = blockId.pool;
		itemBlockIdByVal.block = blockId.block;
		
		ByteByReference retSeqByte = new ByteByReference();
		ByteByReference retDupItemID = new ByteByReference();

		Memory item_name = new Memory(NotesConstants.MAXUSERNAME);
		ShortByReference retName_len = new ShortByReference();
		ShortByReference retItem_flags = new ShortByReference();
		ShortByReference retDataType = new ShortByReference();
		IntByReference retValueLen = new IntByReference();

		NotesBlockIdStruct retValueBid = NotesBlockIdStruct.newInstance();
		
		short result;
		if (PlatformUtils.is64Bit()) {
			
			NotesNativeAPI64.get().NSFItemQueryEx(m_hNote64,
					itemBlockIdByVal, item_name, (short) (item_name.size() & 0xffff), retName_len,
					retItem_flags, retDataType, retValueBid, retValueLen, retSeqByte, retDupItemID);
		}
		else {
			NotesNativeAPI32.get().NSFItemQueryEx(m_hNote32,
					itemBlockIdByVal, item_name, (short) (item_name.size() & 0xffff), retName_len,
					retItem_flags, retDataType, retValueBid, retValueLen, retSeqByte, retDupItemID);
		}

		NotesBlockIdStruct itemBlockIdForItemCreation = NotesBlockIdStruct.newInstance();
		itemBlockIdForItemCreation.pool = itemBlockIdByVal.pool;
		itemBlockIdForItemCreation.block = itemBlockIdByVal.block;
		itemBlockIdForItemCreation.write();
		
		if ((retItem_flags.getValue() & NotesConstants.ITEM_READERS) == NotesConstants.ITEM_READERS) {
			NotesItem firstItem = new NotesItem(this, itemBlockIdForItemCreation, (int) (retDataType.getValue() & 0xffff),
					retValueBid);
			readerFields.add(firstItem);
		}

		//now search for more items with readers flag
		while (true) {
			IntByReference retNextValueLen = new IntByReference();
			
			NotesBlockIdStruct retItemBlockId = NotesBlockIdStruct.newInstance();
			
			if (PlatformUtils.is64Bit()) {
				result = NotesNativeAPI64.get().NSFItemInfoNext(m_hNote64, itemBlockIdByVal,
						null, (short) 0, retItemBlockId, retDataType,
						retValueBid, retNextValueLen);
			}
			else {
				result = NotesNativeAPI32.get().NSFItemInfoNext(m_hNote32, itemBlockIdByVal,
						null, (short) 0, retItemBlockId, retDataType,
						retValueBid, retNextValueLen);
			}

			if (result == INotesErrorConstants.ERR_ITEM_NOT_FOUND) {
				return readerFields;
			}

			NotesErrorUtils.checkResult(result);

			itemBlockIdForItemCreation = NotesBlockIdStruct.newInstance();
			itemBlockIdForItemCreation.pool = retItemBlockId.pool;
			itemBlockIdForItemCreation.block = retItemBlockId.block;
			itemBlockIdForItemCreation.write();
			
			NotesBlockIdStruct valueBlockIdClone = NotesBlockIdStruct.newInstance();
			valueBlockIdClone.pool = retValueBid.pool;
			valueBlockIdClone.block = retValueBid.block;
			valueBlockIdClone.write();
			
			short dataType = retDataType.getValue();

			NotesItem newItem = new NotesItem(this, itemBlockIdForItemCreation, dataType,
					valueBlockIdClone);
			if (newItem.isReaders()) {
				readerFields.add(newItem);
			}
			
			itemBlockIdByVal.pool = retItemBlockId.pool;
			itemBlockIdByVal.block = retItemBlockId.block;
			itemBlockIdByVal.write();
		}
	}
	
	/**
	 * This function deletes this note from the specified database with default flags (0).

	 * 

	 * This function allows using extended 32-bit DWORD update options, as described in the entry {@link UpdateNote}.

	 * 

	 * It deletes the specified note by updating it with a nil body, and marking the note as a deletion stub.

	 * The deletion stub identifies the deleted note to other replica copies of the database.

	 * This allows the replicator to delete copies of the note from replica databases.
	 * 

	 * The deleted note may be of any NOTE_CLASS_xxx.  The active user ID must have sufficient user access
	 * in the databases's Access Control List (ACL) to carry out a deletion on the note or the function
	 * will return an error code.
	 */
	public void delete() {
		delete(EnumSet.noneOf(UpdateNote.class));
	}

	/**
	 * This function deletes this note from the specified database.

	 * 

	 * This function allows using extended 32-bit DWORD update options, as described in the entry {@link UpdateNote}.

	 * 

	 * It deletes the specified note by updating it with a nil body, and marking the note as a deletion stub.

	 * The deletion stub identifies the deleted note to other replica copies of the database.

	 * This allows the replicator to delete copies of the note from replica databases.
	 * 

	 * The deleted note may be of any NOTE_CLASS_xxx.  The active user ID must have sufficient user access
	 * in the databases's Access Control List (ACL) to carry out a deletion on the note or the function
	 * will return an error code.
	 * 
	 * @param flags flags
	 */
	public void delete(EnumSet flags) {
		if (checkForProfileAndDelete()) {
			return;
		}
		
		checkHandle();
		
		if (m_parentDb.isRecycled())
			throw new NotesError(0, "Parent database already recycled");
		
		int flagsAsInt = UpdateNote.toBitMaskForUpdateExt(flags);
		
		short result;
		if (PlatformUtils.is64Bit()) {
			result = NotesNativeAPI64.get().NSFNoteDeleteExtended(m_parentDb.getHandle64(), getNoteId(), flagsAsInt);
		}
		else {
			result = NotesNativeAPI32.get().NSFNoteDeleteExtended(m_parentDb.getHandle32(), getNoteId(), flagsAsInt);
		}
		NotesErrorUtils.checkResult(result);
	}
	
	/**
	 * Checks if this note is a profile. If it is, we use a different C method
	 * to delete it in the database and also delete the profile cache entry.
	 * 
	 * @return true if note is a profile note that has been saved, false otherwise
	 */
	private boolean checkForProfileAndDelete() {
		checkHandle();
		
		if (!isGhost()) {
			return false;
		}
		
		String[] profileNameAndUsername = parseProfileAndUserName();
		
		if (profileNameAndUsername==null) {
			return false;
		}
		
		String profileName = profileNameAndUsername[0];
		String profileUsername = profileNameAndUsername[1];
		
		Memory profileNameMem = NotesStringUtils.toLMBCS(profileName, false);
		Memory profileUsernameMem = StringUtil.isEmpty(profileUsername) ? null : NotesStringUtils.toLMBCS(profileUsername, false);
		
		NotesDatabase parentDb = getParent();
		if (parentDb.isRecycled()) {
			throw new NotesError("Parent database is disposed");
		}
		
		//delete note and remove it from the profile cache
		short result;
		if (PlatformUtils.is64Bit()) {
			result = NotesNativeAPI64.get().NSFProfileDelete(parentDb.getHandle64(),
					profileNameMem, (short) (profileNameMem.size() & 0xffff),
					profileUsernameMem, (short) ((profileUsernameMem==null ? 0 : profileUsernameMem.size()) & 0xffff));
		}
		else {
			result = NotesNativeAPI32.get().NSFProfileDelete(parentDb.getHandle32(),
					profileNameMem, (short) (profileNameMem.size() & 0xffff),
					profileUsernameMem, (short) ((profileUsernameMem==null ? 0 : profileUsernameMem.size()) & 0xffff));
		}
		NotesErrorUtils.checkResult(result);
		
		return true;
	}

	/**
	 * Method to remove an item from a note
	 * 
	 * @param itemName item name
	 */
	public void removeItem(String itemName) {
		checkHandle();
		
		Memory itemNameMem = NotesStringUtils.toLMBCS(itemName, false);
		
		short result;
		if (PlatformUtils.is64Bit()) {
			result = NotesNativeAPI64.get().NSFItemDelete(m_hNote64, itemNameMem, (short) (itemNameMem.size() & 0xffff));
		}
		else {
			result = NotesNativeAPI32.get().NSFItemDelete(m_hNote32, itemNameMem, (short) (itemNameMem.size() & 0xffff));
		}
		if (result==INotesErrorConstants.ERR_ITEM_NOT_FOUND) {
			return;
		}
		NotesErrorUtils.checkResult(result);
	}
	
	/** default size of return buffer for operations returning strings like NSFItemGetText  */
	private final int DEFAULT_STRINGRETVALUE_LENGTH = 16384;
	/** max size of return buffer for operations returning strings like NSFItemGetText  */
	private final int MAX_STRINGRETVALUE_LENGTH = 65535;

	private ThreadLocal stringretBuffer = new ThreadLocal();
	private boolean m_saveMessageOnSend;
	
	/**
	 * Use this function to read the value of a text item.

	 * 

	 * If the item does not exist, the method returns an empty string. Use {@link #hasItem(String)}
	 * to check for item existence.
	 * 
	 * @param itemName item name
	 * @return text value
	 */
	public String getItemValueString(String itemName) {
		List strList = getItemValueStringList(itemName);
		if (strList!=null && !strList.isEmpty()) {
			return strList.get(0);
		}
		else {
			return "";
		}
	}
	
	/**
	 * This function writes an item of type TEXT to the note.

	 * If an item of that name already exists, it deletes the existing item first,
	 * then appends the new item.

	 * 

	 * Note 1: Use \n as line break in your string. The method internally converts these line breaks
	 * to null characters ('\0'), because that's what the Notes API expects as line break delimiter.

	 * 

	 * Note 2: If the Summary parameter of is set to TRUE, the ITEM_SUMMARY flag in the item will be set.
	 * Items with the ITEM_SUMMARY flag set are stored in the note's summary buffer. These items may
	 * be used in view columns,  selection formulas, and @-functions. The maximum size of the summary
	 * buffer is 32K per note.

	 * If you append more than 32K bytes of data in items that have the ITEM_SUMMARY flag set,
	 * this method call will succeed, but {@link #update(EnumSet)} will return ERR_SUMMARY_TOO_BIG (ERR 561).
	 * To avoid this, decide which fields are not used in view columns, selection formulas,
	 * or @-functions. For these "non-computed" fields, use this method with the Summary parameter set to FALSE.

	 * 

	 * API program may read, modify, and write items that do not have the summary flag set, but they
	 * must open the note first. Items that do not have the summary flag set can not be accessed
	 * in the summary buffer.

	 * 
	 * @param itemName item name
	 * @param itemValue item value
	 * @param isSummary true to set summary flag
	 */
	public void setItemValueString(String itemName, String itemValue, boolean isSummary) {
		checkHandle();
		Memory itemNameMem = NotesStringUtils.toLMBCS(itemName, true);
		Memory itemValueMem = NotesStringUtils.toLMBCS(itemValue, false);
		
		if (PlatformUtils.is64Bit()) {
			short result = NotesNativeAPI64.get().NSFItemSetTextSummary(m_hNote64, itemNameMem, itemValueMem, itemValueMem==null ? 0 : ((short) (itemValueMem.size() & 0xffff)), isSummary);
			NotesErrorUtils.checkResult(result);
		}
		else {
			short result = NotesNativeAPI32.get().NSFItemSetTextSummary(m_hNote32, itemNameMem, itemValueMem, itemValueMem==null ? 0 : ((short) (itemValueMem.size() & 0xffff)), isSummary);
			NotesErrorUtils.checkResult(result);
		}
	}

	/**
	 * This function writes a number to an item in the note.
	 * 
	 * @param itemName item name
	 * @param value new value
	 */
	public void setItemValueDouble(String itemName, double value) {
		checkHandle();

		Memory itemNameMem = NotesStringUtils.toLMBCS(itemName, true);
		
		Memory doubleMem = new Memory(Native.getNativeSize(Double.TYPE));
		doubleMem.setDouble(0, value);
		
		if (PlatformUtils.is64Bit()) {
			short result = NotesNativeAPI64.get().NSFItemSetNumber(m_hNote64, itemNameMem, doubleMem);
			NotesErrorUtils.checkResult(result);
		}
		else {
			short result = NotesNativeAPI32.get().NSFItemSetNumber(m_hNote32, itemNameMem, doubleMem);
			NotesErrorUtils.checkResult(result);
		}
	}
	
	/**
	 * Writes a {@link Calendar} value in an item
	 * 
	 * @param itemName item name
	 * @param cal new value
	 */
	public void setItemValueDateTime(String itemName, Calendar cal) {
		if (cal==null) {
			removeItem(itemName);
			return;
		}
		
		checkHandle();

		Memory itemNameMem = NotesStringUtils.toLMBCS(itemName, true);

		NotesTimeDate timeDate = NotesDateTimeUtils.calendarToTimeDate(cal);
		NotesTimeDateStruct timeDateStruct = timeDate==null ? null : NotesTimeDateStruct.newInstance(timeDate.getInnards());
		
		if (PlatformUtils.is64Bit()) {
			short result = NotesNativeAPI64.get().NSFItemSetTime(m_hNote64, itemNameMem, timeDateStruct);
			NotesErrorUtils.checkResult(result);
		}
		else {
			short result = NotesNativeAPI32.get().NSFItemSetTime(m_hNote32, itemNameMem, timeDateStruct);
			NotesErrorUtils.checkResult(result);
		}
	}

	/**
	 * Writes a {@link Date} value in an item
	 * 
	 * @param itemName item name
	 * @param dt new value
	 * @param hasDate true to save the date of the specified {@link Date} object
	 * @param hasTime true to save the time of the specified {@link Date} object
	 */
	public void setItemValueDateTime(String itemName, Date dt, boolean hasDate, boolean hasTime) {
		if (dt==null) {
			removeItem(itemName);
			return;
		}
		
		Calendar cal = Calendar.getInstance();
		cal.setTime(dt);
		if (!hasDate) {
			NotesDateTimeUtils.setAnyDate(cal);
		}
		if (!hasTime) {
			NotesDateTimeUtils.setAnyTime(cal);
		}
		setItemValueDateTime(itemName, cal);
	}

	/**
	 * Reads the value of a text list item
	 * 
	 * @param itemName item name
	 * @return list of strings; empty if item does not exist
	 */
	public List getItemValueStringList(String itemName) {
		List docValues = getItemValue(itemName);
		if (docValues != null) {
			List strList = new ArrayList(docValues.size());
			for (int i = 0; i < docValues.size(); i++) {
				String currStr = docValues.get(i).toString();
				if (!"".equals(currStr)) {
					strList.add(currStr);
				}
			}
			return strList;
		}
		return Collections.emptyList();
	}
	
	/**
	 * This is a very powerful function that converts many kinds of Domino fields (items) into
	 * text strings.

	 * 
	 * If there is more than one item with the same name, this function will always return the first of these.
	 * This function, therefore, is not useful if you want to retrieve multiple instances of the same
	 * field name. For these situations, use {@link NotesItem#getValueAsText(char)}.

	 * 

	 * The item value may be any one of these supported Domino data types:

	 * 

	 * 
{@link NotesItem#TYPE_TEXT} - Text is returned unmodified.
	 * 
{@link NotesItem#TYPE_TEXT_LIST} - A text list items will merged into a single text string, with the separator between them.
	 * 
{@link NotesItem#TYPE_NUMBER} - the FLOAT number will be converted to text.
	 * 
{@link NotesItem#TYPE_NUMBER_RANGE} - the FLOAT numbers will be converted to text, with the separator between them.
	 * 
{@link NotesItem#TYPE_TIME} - the binary Time/Date will be converted to text.
	 * 
{@link NotesItem#TYPE_TIME_RANGE} - the binary Time/Date values will be converted to text, with the separator between them.
	 * 
{@link NotesItem#TYPE_COMPOSITE} - The text portion of the rich text field will be returned.
	 * 
{@link NotesItem#TYPE_USERID} - The user name portion will be converted to text.
	 * 
{@link NotesItem#TYPE_ERROR} - the binary Error value will be converted to "ERROR: ".
	 * 
{@link NotesItem#TYPE_UNAVAILABLE} - the binary Unavailable value will be converted to "UNAVAILABLE: ".
	 * 
	 * 
	 * @param itemName item name
	 * @param multiValueDelimiter delimiter character for value lists; should be an ASCII character, since no encoding is done
	 * @return string value
	 */
	public String getItemValueAsText(String itemName, char multiValueDelimiter) {
		checkHandle();

		Memory itemNameMem = NotesStringUtils.toLMBCS(itemName, true);
		DisposableMemory retItemValueMem = stringretBuffer.get();
		if (retItemValueMem==null || retItemValueMem.isDisposed()) {
			retItemValueMem = new DisposableMemory(DEFAULT_STRINGRETVALUE_LENGTH);
			stringretBuffer.set(retItemValueMem);
		}

		short length;
		if (PlatformUtils.is64Bit()) {
			length = NotesNativeAPI64.get().NSFItemConvertToText(m_hNote64, itemNameMem, retItemValueMem, (short) (retItemValueMem.size() & 0xffff), multiValueDelimiter);
			if (length == (retItemValueMem.size()-1)) {
				retItemValueMem.dispose();
				retItemValueMem = new DisposableMemory(MAX_STRINGRETVALUE_LENGTH);
				stringretBuffer.set(retItemValueMem);
				length = NotesNativeAPI64.get().NSFItemConvertToText(m_hNote64, itemNameMem, retItemValueMem, (short) (retItemValueMem.size() & 0xffff), multiValueDelimiter);
			}
		}
		else {
			length = NotesNativeAPI32.get().NSFItemConvertToText(m_hNote32, itemNameMem, retItemValueMem, (short) (retItemValueMem.size() & 0xffff), multiValueDelimiter);
			if (length == (retItemValueMem.size()-1)) {
				retItemValueMem.dispose();
				retItemValueMem = new DisposableMemory(MAX_STRINGRETVALUE_LENGTH);
				stringretBuffer.set(retItemValueMem);
				length = NotesNativeAPI32.get().NSFItemConvertToText(m_hNote32, itemNameMem, retItemValueMem, (short) (retItemValueMem.size() & 0xffff), multiValueDelimiter);
			}
		}
		int lengthAsInt = (int) length & 0xffff;
		if (lengthAsInt==0) {
			return "";
		}
		
		String strVal = NotesStringUtils.fromLMBCS(retItemValueMem, lengthAsInt);
		return strVal;
	}
	
	/**
	 * Use this function to read the value of a number item as double.

	 * 

	 * If the item does not exist, the method returns 0. Use {@link #hasItem(String)}
	 * to check for item existence.
	 * 
	 * @param itemName item name
	 * @return double value
	 */
	public double getItemValueDouble(String itemName) {
		checkHandle();

		Memory itemNameMem = NotesStringUtils.toLMBCS(itemName, true);
		
		DoubleByReference retNumber = new DoubleByReference();
		
		if (PlatformUtils.is64Bit()) {
			boolean exists = NotesNativeAPI64.get().NSFItemGetNumber(m_hNote64, itemNameMem, retNumber);
			if (!exists) {
				return 0;
			}
		}
		else {
			boolean exists = NotesNativeAPI32.get().NSFItemGetNumber(m_hNote32, itemNameMem, retNumber);
			if (!exists) {
				return 0;
			}
		}
		
		return retNumber.getValue();
	}

	/**
	 * Use this function to read the value of a number item as long.

	 * 

	 * If the item does not exist, the method returns 0. Use {@link #hasItem(String)}
	 * to check for item existence.
	 * 
	 * @param itemName item name
	 * @return long value
	 */
	public long getItemValueLong(String itemName) {
		List values = getItemValue(itemName);
		if (values.size()==0)
			return 0;
		Object firstVal = values.get(0);
		if (firstVal instanceof Number) {
			return ((Number)firstVal).longValue();
		}
		return 0;
	}

	/**
	 * Use this function to read the value of a number item as integer.

	 * 

	 * If the item does not exist, the method returns 0. Use {@link #hasItem(String)}
	 * to check for item existence.
	 * 
	 * @param itemName item name
	 * @return int value
	 */
	public int getItemValueInteger(String itemName) {
		List values = getItemValue(itemName);
		if (values.size()==0)
			return 0;
		Object firstVal = values.get(0);
		if (firstVal instanceof Number) {
			return ((Number)firstVal).intValue();
		}
		return 0;
	}
	
	/**
	 * Use this function to read the value of a timedate item as {@link Calendar}.

	 * 

	 * If the item does not exist, the method returns null.
	 * 
	 * @param itemName item name
	 * @return time date value or null
	 */
	public Calendar getItemValueDateTime(String itemName) {
		checkHandle();

		Memory itemNameMem = NotesStringUtils.toLMBCS(itemName, true);
		
		NotesTimeDateStruct td_item_value = NotesTimeDateStruct.newInstance();
		
		if (PlatformUtils.is64Bit()) {
			boolean exists = NotesNativeAPI64.get().NSFItemGetTime(m_hNote64, itemNameMem, td_item_value);
			if (!exists) {
				return null;
			}
		}
		else {
			boolean exists = NotesNativeAPI32.get().NSFItemGetTime(m_hNote32, itemNameMem, td_item_value);
			if (!exists) {
				return null;
			}
		}
		return td_item_value.toCalendar();
	}

	/**
	 * Use this function to read the value of a timedate item as {@link NotesTimeDate}.

	 * 

	 * If the item does not exist, the method returns null.
	 * 
	 * @param itemName item name
	 * @return time date value or null if not found
	 */
	public NotesTimeDate getItemValueAsTimeDate(String itemName) {
		checkHandle();

		Memory itemNameMem = NotesStringUtils.toLMBCS(itemName, true);
		
		NotesTimeDateStruct td_item_value = NotesTimeDateStruct.newInstance();
		
		if (PlatformUtils.is64Bit()) {
			boolean exists = NotesNativeAPI64.get().NSFItemGetTime(m_hNote64, itemNameMem, td_item_value);
			if (!exists) {
				return null;
			}
		}
		else {
			boolean exists = NotesNativeAPI32.get().NSFItemGetTime(m_hNote32, itemNameMem, td_item_value);
			if (!exists) {
				return null;
			}
		}
		td_item_value.read();
		int[] innards = td_item_value.Innards;
		return new NotesTimeDate(innards);
	}
	
	/**
	 * Decodes an item value
	 * 
	 * @param itemName item name (for logging purpose)
	 * @param valueBlockId value block id
	 * @param valueLength item value length plus 2 bytes for the data type WORD
	 * @return item value as list
	 */
	List