devicemanager.h

Go to the documentation of this file.

/*-*-c++-*-*****************************************************************
 devicemanager.h
 ---------------
 begin       : Sat Dec 20 2003
 copyright   : (C) 2003 by Martin Preuss
 email       : martin@libchipcard.de

 ***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library 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     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef SIMTHETIC_DEVICEMANAGER_H
#define SIMTHETIC_DEVICEMANAGER_H

#include <simthetic/propertylist.h>
#include <simthetic/exceptions.h>
#include <string>
//#include <list>
#include <map>

typedef struct GWEN__XMLNODE GWEN_XMLNODE;

namespace simth {

  class DLLIMPORT DeviceDescription {
    friend class DeviceManager;
  public:
    class IfaceDescr {
      public:
      IfaceDescr();
      IfaceDescr(const std::string& type, 
         const std::string& description, 
         const std::string& multiplied_by = "");
      std::string type;
      std::string description;
      std::string multiplied_by;
    };
    typedef std::vector<IfaceDescr> IfaceList;
  private:
    std::string _name;
    std::string _type;
    std::string _type_escaped;
    std::string _extends;
    PropertyList _properties;
    Property::list_string _libraries;
    bool _abstract;
    std::string _description;
    IfaceList _input_interfaces;
    IfaceList _output_interfaces;
      

    // Read in a propertylist for a given device. If necessary,
    // recursively use this function for its parent devices.
    static void 
      _readDeviceProperties(PropertyList &pl, 
                GWEN_XMLNODE *dn,
                const std::string &dname,
                int depth,
                Property::list_string &sl,
                IfaceList& input_interfaces,
                IfaceList& output_interfaces);

    // Read a propertylist from a node for the given device. No more
    // recursion inside here.
    static void _readPropertylistNode(PropertyList &pl,
                      GWEN_XMLNODE *pnode,
                      const std::string &dname);

    // Read the overriddenproperties element here and remove the
    // respective elements from the given propertylist
    static void _readOverriddenPropNode(PropertyList &pl,
                      GWEN_XMLNODE *pnode,
                      const std::string &dname);

    // Read a interfacelist from a node for the given device. No
    // more recursion inside here.
    static void _readInterfacelistNode(IfaceList& iiflist,
                       GWEN_XMLNODE *pnode,
                       const std::string &dname);

    // Construct a DeviceDescription from the specified devicenode.
    DeviceDescription (GWEN_XMLNODE *devicenode,
               GWEN_XMLNODE *devicelist, 
               const std::string& dname);

  public:
    DeviceDescription();
    ~DeviceDescription();
    
    bool operator==(const DeviceDescription& d) const;

    bool operator<(const DeviceDescription& d) const;

    const std::string &name() const ;

    const std::string &type() const ;

    const std::string &extends() const ;

    const std::string &type_escaped() const ;

    unsigned nr_input_interfaces() const;
    unsigned nr_output_interfaces() const;
    const DeviceDescription::IfaceList& input_interfaces() const;
    const DeviceDescription::IfaceList& output_interfaces() const;

    const PropertyList &properties() const;

    const Property::list_string &libraries() const;

    bool isAbstract() const;

    const std::string& description() const;

    void toStream(std::ostream &os) const;

    static std::string typename_escape(const std::string& s);
    
    static std::string typename_unescape(const std::string& s);
  };




  class DLLIMPORT DeviceManager {

  public:
    typedef simth::DeviceDescription DeviceDescription;

    typedef std::string DDMapKey;

    typedef std::map<DDMapKey, DeviceDescription> DDMap;

    typedef std::vector<DeviceDescription> DeviceDescriptionList;

  private:
    typedef Property::list_string list_string;
    list_string _folderlist;

    // For a given non-absolute filename, check whether it can be
    // found in the search path. Return the absolute filename if yes.
    std::string _getFilePath(const std::string &fname) const 
    throw(file_not_found);

    // Read in the given file name into the given rootnode and return
    // a pointer to the devicelist node.
    GWEN_XMLNODE *_getDevicelistFromFile(const std::string &fname,
                     GWEN_XMLNODE *rootnode)
    throw(file_not_found, bad_device_file);

    // Replace all whitespace characters (tab, newline etc) in a
    // string with one whitespace.
    static std::string condensedString(const std::string &s);

  public:
    DeviceManager(const std::string &folder="");

    virtual ~DeviceManager();

    const std::string& folder() const throw();

    const Property::list_string& folderlist() const throw();

    DDMap allAvailableDescriptions()
    throw(bad_device_file, bad_device_description, type_error);

    DeviceDescriptionList allAvailableDescriptionsList()
    throw(bad_device_file, bad_device_description, type_error);

    DeviceDescriptionList
      allDescriptionsFromFile(const std::string &fname)
    throw(file_not_found, bad_device_file, bad_device_description, 
          type_error);

    DeviceDescription descriptionFromFile(const std::string &fname,
                                          const std::string &dname)
    throw(file_not_found, bad_device_file, device_not_found, type_error);

    Property::list_string allXMLFiles() const;

    static GWEN_XMLNODE *findDeviceNode(GWEN_XMLNODE *dn,
                    const std::string &dname);
    
    static bool string_to_bool(const std::string abstr);

    static std::string getStringData(GWEN_XMLNODE *node);

    static GWEN_XMLNODE *findNodeByName(GWEN_XMLNODE *node,
                    const std::string& node_name,
                    const std::string& filename,
                    bool required = true)
      throw(simth::bad_device_file);

  };

#ifndef __GNUC__
  EXPIMP_TEMPLATE template DLLIMPORT DeviceManager::DDMap;
  EXPIMP_TEMPLATE template DLLIMPORT DeviceManager::DeviceDescriptionList;
#endif

  std::ostream& operator<<(std::ostream&os, const DeviceManager::DDMap& dds);

} /* namespace */


#endif /* SIMTHETIC_DEVICEMANAGER_H */

---