Package org.openntf.domino.impl

Source Code of org.openntf.domino.impl.Item

/*
* Copyright 2013
*
* 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.openntf.domino.impl;

import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.util.ArrayList;
import java.util.Date;
import java.util.EnumSet;
import java.util.List;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;

import lotus.domino.NotesException;

import org.openntf.domino.Database;
import org.openntf.domino.DateTime;
import org.openntf.domino.Document;
import org.openntf.domino.ExceptionDetails;
import org.openntf.domino.MIMEEntity;
import org.openntf.domino.MIMEHeader;
import org.openntf.domino.Session;
import org.openntf.domino.WrapperFactory;
import org.openntf.domino.exceptions.DataNotCompatibleException;
import org.openntf.domino.utils.DominoUtils;
import org.openntf.domino.utils.Factory;
import org.openntf.domino.utils.TypeUtils;
import org.xml.sax.InputSource;

// TODO: Auto-generated Javadoc
/**
* The Class Item.
*/
public class Item extends Base<org.openntf.domino.Item, lotus.domino.Item, Document> implements org.openntf.domino.Item {
  private static final Logger log_ = Logger.getLogger(Item.class.getName());

  // TODO NTF - all setters should check to see if the new value is different from the old and only markDirty if there's a change
  private String name_;
  private Type itemType;
  private EnumSet<Flags> flagSet_;

  /**
   * Instantiates a new item.
   *
   * @param delegate
   *            the delegate
   * @param parent
   *            the parent
   */
  @Deprecated
  public Item(final lotus.domino.Item delegate, final org.openntf.domino.Base<?> parent) {
    super(delegate, (Document) parent);
    initialize(delegate);
  }

  /**
   * Instantiates a new outline.
   *
   * @param delegate
   *            the delegate
   * @param parent
   *            the parent
   * @param wf
   *            the wrapperfactory
   * @param cppId
   *            the cpp-id
   */
  public Item(final lotus.domino.Item delegate, final Document parent, final WrapperFactory wf, final long cppId) {
    super(delegate, parent, wf, cppId, NOTES_ITEM);
    initialize(delegate);
  }

  /**
   * Instatiates a new RichtextItem
   *
   * @param delegate
   * @param parent
   * @param wf
   * @param cppId
   */
  protected Item(final lotus.domino.RichTextItem delegate, final Document parent, final WrapperFactory wf, final long cppId) {
    super(delegate, parent, wf, cppId, NOTES_RTITEM);
    initialize(delegate);
  }

  /* (non-Javadoc)
   * @see org.openntf.domino.impl.Base#findParent(lotus.domino.Base)
   */
  @Override
  protected Document findParent(final lotus.domino.Item delegate) throws NotesException {
    return fromLotus(delegate.getParent(), Document.SCHEMA, null);
  }

  protected void initialize(final lotus.domino.Item delegate) {
    // TODO Auto-generated method stub
    String name;
    try {
      name = delegate.getName();
    } catch (NotesException ne) {
      name = "";
      if (log_.isLoggable(Level.WARNING)) {
        log_.log(Level.WARNING, "Exception trying to get item from Document " + getAncestorDatabase().getFilePath() + " "
            + getAncestorDocument().getNoteID());
      }
      throw new RuntimeException(ne);
    }
    name_ = name;
  }

  private EnumSet<Flags> getFlagSet() {
    if (flagSet_ == null) {
      flagSet_ = EnumSet.noneOf(Flags.class);
      try {
        if (getDelegate().isAuthors())
          flagSet_.add(Flags.AUTHORS);
        if (getDelegate().isEncrypted())
          flagSet_.add(Flags.ENCRYPTED);
        if (getDelegate().isNames())
          flagSet_.add(Flags.NAMES);
        if (getDelegate().isProtected())
          flagSet_.add(Flags.PROTECTED);
        if (getDelegate().isReaders())
          flagSet_.add(Flags.READERS);
        if (getDelegate().isSigned())
          flagSet_.add(Flags.SIGNED);
        if (getDelegate().isSummary())
          flagSet_.add(Flags.SUMMARY);
      } catch (NotesException ne) {
        DominoUtils.handleException(ne);
      }
    }
    return flagSet_;
  }

  // private void initialize(lotus.domino.Item delegate) {
  //
  // }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#abstractText(int, boolean, boolean)
   */
  @Override
  public String abstractText(final int maxLen, final boolean dropVowels, final boolean userDict) {
    try {
      return getDelegate().abstractText(maxLen, dropVowels, userDict);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return null;
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#appendToTextList(java.lang.String)
   */
  @Override
  public void appendToTextList(final String value) {
    markDirty();
    try {
      getDelegate().appendToTextList(value);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#appendToTextList(java.util.Vector)
   */
  @SuppressWarnings({ "unchecked", "rawtypes" })
  @Override
  public void appendToTextList(final Vector values) {
    markDirty();
    List<lotus.domino.Base> recycleThis = new ArrayList();
    try {
      Vector v = toDominoFriendly(values, this, recycleThis);
      getDelegate().appendToTextList(v);

    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
    } finally {
      s_recycle(recycleThis);
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#containsValue(java.lang.Object)
   */
  @Override
  public boolean containsValue(final Object value) {
    List<lotus.domino.Base> recycleThis = new ArrayList<lotus.domino.Base>();
    try {
      boolean result;
      Object domObj = toDominoFriendly(value, this, recycleThis);
      result = getDelegate().containsValue(domObj);
      Base.s_recycle(domObj);
      return result;
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return false;
    } finally {
      s_recycle(recycleThis);
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#copyItemToDocument(lotus.domino.Document)
   */
  @Override
  public org.openntf.domino.Item copyItemToDocument(final lotus.domino.Document lotusDoc) {
    // TODO - mark dirty?
    try {
      if (lotusDoc == null) {
        throw new IllegalArgumentException();
      }

      Document doc = fromLotus(lotusDoc, Document.SCHEMA, null);
      return fromLotus(getDelegate().copyItemToDocument(toLotus(doc)), Item.SCHEMA, doc);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return null;
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#copyItemToDocument(lotus.domino.Document, java.lang.String)
   */
  @Override
  public org.openntf.domino.Item copyItemToDocument(final lotus.domino.Document lotusDoc, final String newName) {
    // TODO - mark dirty?
    try {
      if (lotusDoc == null) {
        throw new IllegalArgumentException();
      }

      Document doc = fromLotus(lotusDoc, Document.SCHEMA, null); // TODO: this is not yet optimal. wrap document with it's session & db
      return fromLotus(getDelegate().copyItemToDocument(toLotus(doc), newName), Item.SCHEMA, doc);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return null;
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#getDateTimeValue()
   */
  @Override
  public DateTime getDateTimeValue() {
    //    System.out.println("Getting DateTime value from item " + getName());
    try {
      lotus.domino.DateTime delegate = getDelegate().getDateTimeValue();
      if (delegate == null) {
        //        System.out.println("Delegate DateTime is null for item " + getName() + " in doc " + getAncestorDocument().getUniversalID());
      }
      return fromLotus(delegate, DateTime.SCHEMA, getAncestorSession());
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return null;
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#getInputSource()
   */
  @Override
  public InputSource getInputSource() {
    try {
      return getDelegate().getInputSource();
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return null;
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#getInputStream()
   */
  @Override
  public InputStream getInputStream() {
    try {
      return getDelegate().getInputStream();
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return null;
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#getLastModified()
   */
  @Override
  public DateTime getLastModified() {
    try {
      return fromLotus(getDelegate().getLastModified(), DateTime.SCHEMA, getAncestorSession());
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return null;
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#getLastModified()
   */
  @Override
  public Date getLastModifiedDate() {
    try {
      lotus.domino.DateTime dt = getDelegate().getLastModified();
      if (dt == null) {
        return getParent().getLastModifiedDate();
      } else {
        java.util.Date jdate = dt.toJavaDate();
        return jdate;
      }
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return null;
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#getMIMEEntity()
   */
  @Override
  public MIMEEntity getMIMEEntity() {
    //    System.err.println("GetMIMEEntity in Item");
    return getParent().getMIMEEntity(getName());
    //    try {
    //      return fromLotus(getDelegate().getMIMEEntity(), MIMEEntity.SCHEMA, this.getParent());
    //    } catch (NotesException e) {
    //      DominoUtils.handleException(e);
    //      return null;
    //    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#getName()
   */
  @Override
  public String getName() {
    try {
      return getDelegate().getName();
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return null;
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.impl.Base#getParent()
   */
  @Override
  public Document getParent() {
    return getAncestor();
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#getReader()
   */
  @Override
  public Reader getReader() {
    try {
      return getDelegate().getReader();
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return null;
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#getText()
   */
  @Override
  public String getText() {
    try {
      return getDelegate().getText();
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return null;
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#getText(int)
   */
  @Override
  public String getText(final int maxLen) {
    try {
      return getDelegate().getText(maxLen);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return null;
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#getType()
   */
  @Override
  @Deprecated
  public int getType() {
    return getTypeEx().getValue();
  }

  @Override
  public Type getTypeEx() {
    try {
      if (itemType == null) {
        itemType = Type.valueOf(getDelegate().getType());
      }
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
    }

    if (itemType == Type.MIME_PART) {
      MIMEEntity entity = getMIMEEntity();
      if (entity != null) {
        MIMEHeader contentType = entity.getNthHeader("Content-Type");
        String headerval = contentType.getHeaderVal();
        if ("application/x-java-serialized-object".equals(headerval) || "application/x-java-externalized-object".equals(headerval)) {
          itemType = Type.MIME_BEAN;
        }
        getParent().closeMIMEEntities(false, getName());
      }
    }

    return itemType;
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#getValueCustomData()
   */
  @Override
  public Object getValueCustomData() throws IOException, ClassNotFoundException {
    try {
      return getDelegate().getValueCustomData();
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return null;
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#getValueCustomData(java.lang.String)
   */
  @Override
  public Object getValueCustomData(final String dataTypeName) throws IOException, ClassNotFoundException {
    try {
      return getDelegate().getValueCustomData(dataTypeName);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return null;
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#getValueCustomDataBytes(java.lang.String)
   */
  @Override
  public byte[] getValueCustomDataBytes(final String dataTypeName) throws IOException {
    try {
      return getDelegate().getValueCustomDataBytes(dataTypeName);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return null;
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#getValueDateTimeArray()
   */
  @Override
  public Vector<org.openntf.domino.DateTime> getValueDateTimeArray() {
    //    System.out.println("Getting DateTimeArray value from item " + getName());
    try {
      return fromLotusAsVector(getDelegate().getValueDateTimeArray(), org.openntf.domino.DateTime.SCHEMA, getAncestorSession());
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return null;
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#getValueDouble()
   */
  @Override
  public double getValueDouble() {
    try {
      return getDelegate().getValueDouble();
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return 0d;
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#getValueInteger()
   */
  @Override
  public int getValueInteger() {
    try {
      return getDelegate().getValueInteger();
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return 0;
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#getValueLength()
   */
  @Override
  public int getValueLength() {
    try {
      return getDelegate().getValueLength();
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return 0;
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#getValueString()
   */
  @Override
  public String getValueString() {
    try {
      return getDelegate().getValueString();
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return null;
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#getValues()
   */
  @Override
  public Vector<Object> getValues() {
    // Just use the parent Doc for this, since it understands MIMEBean
    // Check for null in case there was a problem with the parent's method
    Vector<Object> values = this.getParent().getItemValue(this.getName());
    if (values != null) {
      return new Vector<Object>(values);
    } else {
      log_.log(Level.WARNING, "Item " + getName() + " in document " + getAncestorDatabase().getApiPath() + ": "
          + getParent().getNoteID() + " is a NULL");
    }
    return null;
  }

  @Override
  public <T> T getValues(final Class<?> T) {
    return TypeUtils.itemValueToClass(this, T);
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#isAuthors()
   */
  @Override
  public boolean isAuthors() {
    return getFlagSet().contains(Flags.AUTHORS);
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#isEncrypted()
   */
  @Override
  public boolean isEncrypted() {
    return getFlagSet().contains(Flags.ENCRYPTED);
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#isNames()
   */
  @Override
  public boolean isNames() {
    return getFlagSet().contains(Flags.NAMES);
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#isProtected()
   */
  @Override
  public boolean isProtected() {
    return getFlagSet().contains(Flags.PROTECTED);
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#isReaders()
   */
  @Override
  public boolean isReaders() {
    return getFlagSet().contains(Flags.READERS);
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#isSaveToDisk()
   */
  @Override
  public boolean isSaveToDisk() {
    try {
      return getDelegate().isSaveToDisk();
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return false;
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#isSigned()
   */
  @Override
  public boolean isSigned() {
    return getFlagSet().contains(Flags.SIGNED);
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#isSummary()
   */
  @Override
  public boolean isSummary() {
    return getFlagSet().contains(Flags.SUMMARY);
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#parseXML(boolean)
   */
  @Override
  public org.w3c.dom.Document parseXML(final boolean validate) throws IOException {
    try {
      return getDelegate().parseXML(validate);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
      return null;
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#remove()
   */
  @Override
  public void remove() {
    markDirty();
    try {
      getDelegate().remove();
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#setAuthors(boolean)
   */
  @Override
  public void setAuthors(final boolean flag) {
    markDirty();
    try {
      // Make sure it's a text field!!
      if (flag) {
        if (getTypeEx() == Type.AUTHORS) {
          return;
        }
        if (!isReadersNamesAuthors()) {
          if (getTypeEx() != Type.TEXT) {
            throw new DataNotCompatibleException("Field " + getName() + " is not Text so cannot be set as an Authors field");
          }
        }
      }
      getDelegate().setAuthors(flag);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#setDateTimeValue(lotus.domino.DateTime)
   */
  @Override
  public void setDateTimeValue(final lotus.domino.DateTime dateTime) {
    markDirty();
    @SuppressWarnings("rawtypes")
    List recycleThis = new ArrayList();
    try {
      getDelegate().setDateTimeValue(toLotus(dateTime, recycleThis));
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
    } finally {
      s_recycle(recycleThis);
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#setEncrypted(boolean)
   */
  @Override
  public void setEncrypted(final boolean flag) {
    markDirty();
    try {
      getDelegate().setEncrypted(flag);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#setNames(boolean)
   */
  @Override
  public void setNames(final boolean flag) {
    markDirty();
    try {
      // Make sure it's a text field!!
      if (flag) {
        if (hasFlag(Flags.NAMES)) {
          return;
        }
        if (!isReadersNamesAuthors()) {
          if (getTypeEx() != Type.TEXT) {
            throw new DataNotCompatibleException("Field " + getName() + " is not Text so cannot be set as an Names field");
          }
        }
      }
      getDelegate().setNames(flag);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#setProtected(boolean)
   */
  @Override
  public void setProtected(final boolean flag) {
    markDirty();
    try {
      getDelegate().setProtected(flag);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#setReaders(boolean)
   */
  @Override
  public void setReaders(final boolean flag) {
    markDirty();
    try {
      // Make sure it's a text field!!
      if (flag) {
        if (getTypeEx() == Type.READERS) {
          return;
        }
        if (!isReadersNamesAuthors()) {
          if (getTypeEx() != Type.TEXT) {
            throw new DataNotCompatibleException("Field " + getName() + " is not Text so cannot be set as an Readers field");
          }
        }
      }
      getDelegate().setReaders(flag);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#setSaveToDisk(boolean)
   */
  @Override
  public void setSaveToDisk(final boolean flag) {
    markDirty();
    try {
      getDelegate().setSaveToDisk(flag);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#setSigned(boolean)
   */
  @Override
  public void setSigned(final boolean flag) {
    markDirty();
    try {
      getDelegate().setSigned(flag);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#setSummary(boolean)
   */
  @Override
  public void setSummary(final boolean flag) {
    markDirty();
    try {
      getDelegate().setSummary(flag);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#setValueCustomData(java.lang.Object)
   */
  @Override
  public void setValueCustomData(final Object userObj) throws IOException {
    markDirty();
    try {
      getDelegate().setValueCustomData(userObj);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#setValueCustomData(java.lang.String, java.lang.Object)
   */
  @Override
  public void setValueCustomData(final String dataTypeName, final Object userObj) throws IOException {
    markDirty();
    try {
      getDelegate().setValueCustomData(dataTypeName, userObj);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#setValueCustomDataBytes(java.lang.String, byte[])
   */
  @Override
  public void setValueCustomDataBytes(final String dataTypeName, final byte[] byteArray) throws IOException {
    markDirty();
    try {
      getDelegate().setValueCustomData(dataTypeName, byteArray);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#setValueDouble(double)
   */
  @Override
  public void setValueDouble(final double value) {
    markDirty();
    try {
      getDelegate().setValueDouble(value);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#setValueInteger(int)
   */
  @Override
  public void setValueInteger(final int value) {
    markDirty();
    try {
      getDelegate().setValueInteger(value);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#setValueString(java.lang.String)
   */
  @Override
  public void setValueString(final String value) {
    markDirty();
    try {
      getDelegate().setValueString(value);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
    }
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#setValues(java.util.Vector)
   */
  @SuppressWarnings("rawtypes")
  @Override
  public void setValues(final java.util.Vector values) {
    markDirty();
    List<lotus.domino.Base> recycleThis = new ArrayList<lotus.domino.Base>();
    try {
      java.util.Vector v = toDominoFriendly(values, this, recycleThis);
      getDelegate().setValues(v);
      s_recycle(v);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
    }
  }

  public void setValues(final Object value) {
    this.getParent().replaceItemValue(this.getName(), value);
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.Item#transformXML(java.lang.Object, lotus.domino.XSLTResultTarget)
   */
  @Override
  public void transformXML(final Object style, final lotus.domino.XSLTResultTarget result) {
    try {
      getDelegate().transformXML(style, result);
    } catch (NotesException e) {
      DominoUtils.handleException(e, this);
    }
  }

  @Override
  public void markDirty() {
    itemType = null; // RPr: not sure if the datatype has changed. So to be sure, we set it to zero
    getAncestorDocument().markDirty();
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.types.DocumentDescendant#getAncestorDocument()
   */
  @Override
  public Document getAncestorDocument() {
    return this.getParent();
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.types.DatabaseDescendant#getAncestorDatabase()
   */
  @Override
  public Database getAncestorDatabase() {
    return this.getParent().getAncestorDatabase();
  }

  /*
   * (non-Javadoc)
   *
   * @see org.openntf.domino.types.SessionDescendant#getAncestorSession()
   */
  @Override
  public Session getAncestorSession() {
    return this.getParent().getAncestorSession();
  }

  @Override
  protected lotus.domino.Item getDelegate() {
    lotus.domino.Item item = super.getDelegate();
    try {
      item.isEncrypted();
    } catch (NotesException recycleSucks) {
      resurrect();
    }
    return super.getDelegate();
  }

  private void resurrect() {
    if (name_ != null) {
      try {
        lotus.domino.Document d = toLotus(getAncestorDocument());
        lotus.domino.Item item = d.getFirstItem(name_);
        setDelegate(item, 0);
        Factory.recacheLotus(d, this, parent_);
        if (log_.isLoggable(Level.INFO)) {
          log_.log(Level.INFO, "Item " + name_ + " in document path " + getAncestorDocument().getNoteID()
              + " had been recycled and was auto-restored. Changes may have been lost.");
          log_.log(Level.FINE,
              "If you recently rollbacked a transaction and this document was included in the rollback, this outcome is normal.");
          if (log_.isLoggable(Level.FINER)) {
            Throwable t = new Throwable();
            StackTraceElement[] elements = t.getStackTrace();
            log_.log(Level.FINER,
                elements[0].getClassName() + "." + elements[0].getMethodName() + " ( line " + elements[0].getLineNumber()
                    + ")");
            log_.log(Level.FINER,
                elements[1].getClassName() + "." + elements[1].getMethodName() + " ( line " + elements[1].getLineNumber()
                    + ")");
            log_.log(Level.FINER,
                elements[2].getClassName() + "." + elements[2].getMethodName() + " ( line " + elements[2].getLineNumber()
                    + ")");
          }
        }
      } catch (NotesException e) {
        DominoUtils.handleException(e, this);
      }
    } else {
      if (log_.isLoggable(Level.WARNING)) {
        log_.log(Level.WARNING, getClass().getSimpleName()
            + " doesn't have name value. Something went terribly wrong. Nothing good can come of this...");
      }
    }
  }

  @Override
  public boolean hasFlag(final org.openntf.domino.Item.Flags flag) {
    switch (flag) {
    case PROTECTED:
      return isProtected();
    case AUTHORS:
      return isAuthors();
    case ENCRYPTED:
      return isEncrypted();
    case NAMES:
      return isNames();
    case READERS:
      return isReaders();
    case SIGNED:
      return isSigned();
    case SUMMARY:
      return isSummary();
    default:
      break;
    }
    return false;
  }

  @Override
  public boolean isReadersNamesAuthors() {
    return (hasFlag(Flags.NAMES) || hasFlag(Flags.READERS) || hasFlag(Flags.AUTHORS));
  }

  @Override
  public void fillExceptionDetails(final List<ExceptionDetails.Entry> result) {
    Document myDoc = getParent();
    if (myDoc != null)
      myDoc.fillExceptionDetails(result);
    String myDetail = name_;
    try {
      myDetail = ", Type:" + getDelegate().getType();
    } catch (NotesException e) {
      myDetail += ", [getType -> NotesException: " + e.text + "]";
    }

    try {
      myDetail = ", ValueString:" + getDelegate().getValueString();
    } catch (NotesException e) {
      myDetail += ", [ValueString -> NotesException: " + e.text + "]";
    }
    result.add(new ExceptionDetails.Entry(this, myDetail));
  }

}
TOP

Related Classes of org.openntf.domino.impl.Item

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.