Home

Libraries

Author

Links

---

device.hpp

Go to the documentation of this file.

/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (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.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is the SysToMath IO C++ Libraries package (LibStmIo).
 *
 * The Initial Developer of the Original Code is
 * Tom Michaelis, SysToMath.
 * Portions created by the Initial Developer are Copyright (C) 2006-2007
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

/******************************************************************************
 *                       First Release 2006-04-30
 ******************************************************************************/


#ifndef STM_DEVICE_HPP
#define STM_DEVICE_HPP


// Include header files for implementation.
#include <stm/impl/xdevice.hpp>


namespace stm
{




struct StmDllSpec Uuid
{
    static const size_t Size = 16;

    Uuid ();

    explicit Uuid (const unsigned char array [Size]);

    Uuid
    (
        unsigned long l,
        unsigned short w1,
        unsigned short w2,
        unsigned char b1,
        unsigned char b2,
        unsigned char b3,
        unsigned char b4,
        unsigned char b5,
        unsigned char b6,
        unsigned char b7,
        unsigned char b8
    );

    Uuid (const Uuid &other);

    Uuid &operator= (const Uuid &other);

    std::string string () const;

    bool isNull () const;

    bool operator== (const Uuid &other) const;

    bool operator!= (const Uuid &other) const;

    bool operator<  (const Uuid &other) const;

    bool operator>  (const Uuid &other) const;

    bool operator<= (const Uuid &other) const;

    bool operator>= (const Uuid &other) const;

    unsigned char octet [Size];
};


}  // namespace stm.


// Include stm::Device base class implementation.
#include <stm/impl/xdevice.hpp>


namespace stm
{






class StmDllSpec Device :
    private local::xDevice  // Implementation DeviceImpl.
{
public:
    enum OpenMode
    {
        NoAccess        = 0x00000000,       
        ReadAccess      = 0x00000001,       
        WriteAccess     = 0x00000002,       
        ReadWriteAccess = ReadAccess | WriteAccess  
    };

    enum ErrorState
    {
        NoError          = 0,   
        ReadError        = 1,   
        WriteError       = 2,   
        ControlError     = 3,   
        ResourceError    = 4,   
        OpenError        = 5,   
        CloseError       = 6,   
        SeekError        = 7,   

        ArgumentError    = 8,   
        UnknownError     = 9    
    };

    enum ErrorFlags
    {
        ErrorFlagMask    = 0x7fff0000,   

        SystemError      = 0x00010000    


    };

    enum
    {
        NoFlags          = 0x00000000,   
        AcceptTimeout    = 0x00000001    
    };

    enum DescribeFlags
    {
        IndentMask        = 0x0000000f,

        IndentFirst       = IndentMask + 1,

        NoPropertyNames   = IndentFirst << 1,

        DefaultProperties = NoPropertyNames << 1,

        VerboseProperties = DefaultProperties << 1 | DefaultProperties,

        AllProperties     = ~ ((DefaultProperties << 2) - 1),

        DeviceType        = DefaultProperties << 2,

        DeviceUuid        = DeviceType << 1,

        DriverVersion     = DeviceUuid << 1
    };

    enum Timeout
    {
        DefaultTimeout  = -1,      
        Forever         = INT_MAX  
    };

    // Forward reference.
    struct Version;

    struct Descriptor : public std::pair<void *, void (*) ()>
    {
        Descriptor (void *d = NULL, void (*f) () = NULL);

        operator const void * () const;
    };

    Device
    (
        const Uuid &uuid = Uuid (),
        const std::string type = std::string (),
        int defaultTimeout = Forever,
        const Descriptor &descr = Descriptor ()
    );

    Device
    (
        int defaultTimeout,
        const Descriptor &descr = Descriptor ()
    );

    Device
    (
        const Uuid &uuid,
        const std::string type,
        const Version &version,
        int defaultTimeout = Forever,
        const Descriptor &descr = Descriptor ()
    );

    Device (const Device &other);

    Device &operator= (const Device &other);

    virtual ~Device ();

    virtual const Uuid &uuid () const;

    virtual void setUuid (const Uuid &uuid);

    const std::string &property (const std::string &name) const;

    void setProperty (const std::string &name, const std::string &value);

    bool unsetProperty (const std::string &name);

    bool hasProperty (const std::string &name);

    virtual const std::string &type () const;

    virtual void setType (const std::string &type);

    virtual Version version () const;

    virtual void setVersion (const Version &version);

    virtual int defaultTimeout () const;

    virtual void setDefaultTimeout (int defaultTimeout = Forever);

    virtual const Descriptor &descr () const;

    virtual void setDescr (const Descriptor &descr) = 0;

    virtual bool canRead () const;

    virtual bool canWrite () const;

    virtual bool canControl () const;

    virtual bool canSeek () const;

    virtual int error () const;

    virtual void setError (int error,
                           const std::string &msg = std::string ()) const;

    virtual void clearError () const;

    virtual std::string errorString (bool msgOnly = false) const;

    virtual void augmentErrorString
    (
        const std::string &prefix,
        const std::string &suffix = std::string ()
    ) const;

    virtual bool isOpen () const;

    virtual unsigned int openMode () const;

    virtual bool open (unsigned int openMode = ReadWriteAccess);

    virtual bool close ();

    virtual int64_t read (void *data, int64_t maxLen,
                          int timeout = DefaultTimeout,
                          unsigned int flags = NoFlags);

    virtual int64_t write (const void *data, int64_t len,
                           int timeout = DefaultTimeout,
                           unsigned int flags = NoFlags);

    virtual int64_t control (unsigned int request,
                             const void *inData, int64_t inLen,
                             void *outData, int64_t maxOutLen,
                             int timeout = DefaultTimeout,
                             unsigned int flags = NoFlags) const;

    virtual int64_t size () const;

    virtual int64_t pos () const;

    virtual bool seek (int64_t pos);

    virtual bool reset ();

    virtual std::ostream &describe
    (
        std::ostream &os,
        unsigned int flags = DefaultProperties
    ) const;

private:

    virtual Device *proxy ();

    virtual const Device *proxy () const;
};


std::ostream &operator<< (std::ostream &os, const Device &device);


struct Device::Version
{
    enum Parts
    {
        Major = 3,  
        Minor = 2,  
        Micro = 1,  
        Nano  = 0   
    };

    Version ();

    Version (unsigned short major, unsigned minor,
             unsigned micro = 0, unsigned nano = 0);

    Version (const Version &other);

    Version &operator= (const Version &other);

    std::string string () const;

    bool isNull () const;

    bool operator== (const Version &other) const;

    bool operator!= (const Version &other) const;

    bool operator<  (const Version &other) const;

    bool operator>  (const Version &other) const;

    bool operator<= (const Version &other) const;

    bool operator>= (const Version &other) const;

    unsigned short part [4];
};

}  // namespace stm.


// Include inline implementation.
#include <stm/impl/xdevice.hpp>


#endif  // STM_DEVICE_HPP

---

© Copyright Tom Michaelis 2002-2007

Distributed under the SysToMath Software License (See the accompanying file license.txt or a copy at www.SysToMath.com).