/**
 * Copyright (C) 2003  Michael P. Kearney   Email: Michael_Kearney@ACM.org
 *
 * 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, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
package org.dmtf.cim;

import java.util.Date;

/**
 * A MediaAccessDevice represents the ability to access one or more media and use this media to store and retrieve data.
 */
public interface CIM_MediaAccessDevice
    extends CIM_LogicalDevice
{
 
    /**
     * A free form string indicating the algorithm or tool used by the device to support compression. If it is not possible or not desired to describe the compression scheme (perhaps because it is not known), recommend using the following words: "Unknown" to represent that it is not known whether the device supports compression capabilities or not, "Compressed" to represent that the device supports compression capabilities but either its compression scheme is not known or not disclosed, and "Not Compressed" to represent that the devices does not support compression capabilities.
     */
    public String getCompressionMethod();
     
    /**
     * Default block size, in bytes, for this Device.
     */
    public long getDefaultBlockSize();
     
    /**
     * ErrorMethodology is a free-form string describing the type(s) of error detection and correction supported by this Device.
     */
    public String getErrorMethodology();
     
    /**
     * The date and time on which the Device was last cleaned.
     */
    public Date getLastCleaned();
     
    /**
     * Time in milliseconds from 'load' to being able to read or write a Media. For example, for DiskDrives, this is the interval between a disk not spinning to the disk reporting that it is ready for read/write (ie, the disk spinning at nominal speeds). For TapeDrives, this is the time from a Media being injected to reporting that it is ready for an application. This is usually at the tape's BOT area.
     */
    public long getLoadTime();
     
    /**
     * Time in milliseconds to move from the first location on the Media to the location that is furthest with respect to time. For a DiskDrive, this represents full seek + full rotational delay. For TapeDrives, this represents a search from the beginning of the tape to the most physically distant point. (The end of a tape may be at its most physically distant point, but this is not necessarily true.)
     */
    public long getMaxAccessTime();
     
    /**
     * Maximum block size, in bytes, for media accessed by this Device.
     */
    public long getMaxBlockSize();
     
    /**
     * Maximum size, in KBytes, of media supported by this Device. KBytes is interpreted as the number of bytes multiplied by 1000 (NOT the number of bytes multiplied by 1024).
     */
    public long getMaxMediaSize();
     
    /**
     * An unsigned integer indicating the maximum 'units' that can be used, with respect to the AccessDevice, before the Device should be cleaned. The property, UnitsDescription, defines how 'units' should be interpreted.
     */
    public long getMaxUnitsBeforeCleaning();
     
    /**
     * True indicates that the media is locked in the Device and can not be ejected. For non-removeable Devices, this value should be true.
     */
    public boolean getMediaIsLocked();
     
    /**
     * Minimum block size, in bytes, for media accessed by this Device.
     */
    public long getMinBlockSize();
     
    /**
     * For a MediaAccessDevice that supports removable Media, the number of times that Media have been mounted for data transfer or to clean the Device. For Devices accessing nonremovable Media, such as hard disks, this property is not applicable and should be set to 0.
     */
    public long getMountCount();
     
    /**
     * Boolean indicating that the MediaAccessDevice needs cleaning. Whether manual or automatic cleaning is possible is indicated in the Capabilities array property.
     */
    public boolean getNeedsCleaning();
     
    /**
     * When the MediaAccessDevice supports multiple individual Media, this property defines the maximum number which can be supported or inserted.
     */
    public int getNumberOfMediaSupported();
     
    /**
     * An enumeration indicating the operational security defined for the MediaAccessDevice. For example, information that the Device is "Read Only" (value=4) or "Boot Bypass" (value=6) can be described using this property.
     */
    public short getSecurity();
     
    /**
     * For a MediaAccessDevice that supports removable Media, the most recent date and time that Media was mounted on the Device. For Devices accessing nonremovable Media, such as hard disks, this property has no meaning and is not applicable.
     */
    public Date getTimeOfLastMount();
     
    /**
     * For a MediaAccessDevice that supports removable Media, the total time (in seconds) that Media have been mounted for data transfer or to clean the Device. For Devices accessing nonremovable Media, such as hard disks, this property is not applicable and should be set to 0.
     */
    public long getTotalMountTime();
     
    /**
     * The sustained data transfer rate in KB/sec that the Device can read from and write to a Media. This is a sustained, raw data rate. Maximum rates or rates assuming compression should not be reported in this property.
     */
    public int getUncompressedDataRate();
     
    /**
     * Defines 'Units' relative to its use in the property, MaxUnitsBeforeCleaning. This describes the criteria used to determine when the MediaAccessDevice should be cleaned.
     */
    public String getUnitsDescription();
     
    /**
     * An unsigned integer indicating the currently used 'units' of the AccessDevice, helpful to describe when the Device may require cleaning. The property, UnitsDescription, defines how 'units' should be interpreted.
     */
    public long getUnitsUsed();
     
    /**
     * Time in milliseconds from being able to read or write a Media to its 'unload'. For example, for DiskDrives, this is the interval between a disk spinning at nominal speeds and a disk not spinning. For TapeDrives, this is the time for a Media to go from its BOT to being fully ejected and accessible to a PickerElement or human operator.
     */
    public long getUnloadTime();
     
    /**
     * Set the CompressionMethod property.
     * @see #getCompressionMethod
     */
    public void setCompressionMethod( String aCompressionMethod );
     
    /**
     * Set the DefaultBlockSize property.
     * @see #getDefaultBlockSize
     */
    public void setDefaultBlockSize( long aDefaultBlockSize );
     
    /**
     * Set the ErrorMethodology property.
     * @see #getErrorMethodology
     */
    public void setErrorMethodology( String aErrorMethodology );
     
    /**
     * Set the LastCleaned property.
     * @see #getLastCleaned
     */
    public void setLastCleaned( Date aLastCleaned );
     
    /**
     * Set the LoadTime property.
     * @see #getLoadTime
     */
    public void setLoadTime( long aLoadTime );
     
    /**
     * Set the MaxAccessTime property.
     * @see #getMaxAccessTime
     */
    public void setMaxAccessTime( long aMaxAccessTime );
     
    /**
     * Set the MaxBlockSize property.
     * @see #getMaxBlockSize
     */
    public void setMaxBlockSize( long aMaxBlockSize );
     
    /**
     * Set the MaxMediaSize property.
     * @see #getMaxMediaSize
     */
    public void setMaxMediaSize( long aMaxMediaSize );
     
    /**
     * Set the MaxUnitsBeforeCleaning property.
     * @see #getMaxUnitsBeforeCleaning
     */
    public void setMaxUnitsBeforeCleaning( long aMaxUnitsBeforeCleaning );
     
    /**
     * Set the MediaIsLocked property.
     * @see #getMediaIsLocked
     */
    public void setMediaIsLocked( boolean aMediaIsLocked );
     
    /**
     * Set the MinBlockSize property.
     * @see #getMinBlockSize
     */
    public void setMinBlockSize( long aMinBlockSize );
     
    /**
     * Set the MountCount property.
     * @see #getMountCount
     */
    public void setMountCount( long aMountCount );
     
    /**
     * Set the NeedsCleaning property.
     * @see #getNeedsCleaning
     */
    public void setNeedsCleaning( boolean aNeedsCleaning );
     
    /**
     * Set the NumberOfMediaSupported property.
     * @see #getNumberOfMediaSupported
     */
    public void setNumberOfMediaSupported( int aNumberOfMediaSupported );
     
    /**
     * Set the Security property.
     * @see #getSecurity
     */
    public void setSecurity( short aSecurity );
     
    /**
     * Set the TimeOfLastMount property.
     * @see #getTimeOfLastMount
     */
    public void setTimeOfLastMount( Date aTimeOfLastMount );
     
    /**
     * Set the TotalMountTime property.
     * @see #getTotalMountTime
     */
    public void setTotalMountTime( long aTotalMountTime );
     
    /**
     * Set the UncompressedDataRate property.
     * @see #getUncompressedDataRate
     */
    public void setUncompressedDataRate( int aUncompressedDataRate );
     
    /**
     * Set the UnitsDescription property.
     * @see #getUnitsDescription
     */
    public void setUnitsDescription( String aUnitsDescription );
     
    /**
     * Set the UnitsUsed property.
     * @see #getUnitsUsed
     */
    public void setUnitsUsed( long aUnitsUsed );
     
    /**
     * Set the UnloadTime property.
     * @see #getUnloadTime
     */
    public void setUnloadTime( long aUnloadTime );
    
}