src/Factory.cc

   1 /*
   2  * Factory.cc
   3  *
   4  *  Created on: Dec 11, 2010
   5  *      Author: lamikr
   6  */
   7
   8 #include <string>
   9 #include <sstream>
  10 #include <iostream>
  11
  12 #include <string.h>
  13
  14 #include <plp/log.h>
  15 #include "Factory.hh"
  16 #include "W1TemperatureSensor.hh"
  17 #include "W1CounterDevice.hh"
  18 #include "W1Util.hh"
  19
  20 using namespace w1;
  21 using namespace std;
  22
  23 template <class NumberDataType>
  24 bool string_to_number(NumberDataType& result,
  25                  const std::string& string_param,
  26                  std::ios_base& (*format)(std::ios_base&))
  27 {
  28         std::istringstream iss(string_param);
  29         return !(iss >> format >> result).fail();
  30 }
  31
  32 Factory::Factory() {
  33         // TODO Auto-generated constructor stub
  34 }
  35
  36 Factory::~Factory() {
  37         // TODO Auto-generated destructor stub
  38 }
  39
  40 W1Device *Factory::get_device(int family_code,
  41                         string device_id,
  42                         dirent *direntry_param) {
  43         W1Device        *ret_val;
  44         DeviceConfig    *config;
  45         string          type;
  46
  47         ret_val = NULL;
  48         switch(family_code) {
  49                 case    0x10:
  50                 case    0x28:
  51                         ret_val = new W1TemperatureSensor(family_code, device_id, direntry_param);
  52                         break;
  53                 case    0x1d:
  54                         ret_val = new W1CounterDevice(family_code, device_id, direntry_param);
  55                         break;
  56                 case    0x81:
  57                         // 0x81 is the 1-wire USB dongle... No need to create device for it.
  58                         break;
  59                 default:
  60                         log_debug("Unsupported 1-wire-family code: %#x, device not created: %s\n", family_code, device_id.c_str());
  61                         break;
  62         }
  63         if (ret_val != NULL) {
  64                 log_debug("%s: %#x\n", ret_val->get_device_type().c_str(), ret_val->get_w1_family_code());
  65                 // check that device config exist
  66                 config  = get_device_config(device_id);
  67                 if (config != NULL) {
  68                         // if not, create default device config
  69                         type    = config->get_cfg_value(DEVICE_CONFIG_VALUE_KEY__TYPE);
  70                         if (type.empty() == true) {
  71                                 type    = ret_val->get_device_type();
  72                                 config->set_cfg_value(DEVICE_CONFIG_VALUE_KEY__TYPE, type);
  73                                 config->set_cfg_value(DEVICE_CONFIG_VALUE_KEY__ID, ret_val->get_id());
  74                         }
  75                         delete(config);
  76                 }
  77         }
  78         return ret_val;
  79 }
  80
  81 W1Device *Factory::create_device(dirent *direntry_param, int *err_code_param) {
  82         string          folder_name;
  83         string          tmp_str;
  84         string          device_name;
  85         int             pos;
  86         int             family_code;
  87         bool            suc_flg;
  88         W1Device        *ret_val;
  89
  90         ret_val         = NULL;
  91         *err_code_param = 0;
  92         folder_name     = direntry_param->d_name;
  93         pos             = folder_name.find("-");
  94         if (pos > 0) {
  95                 tmp_str = folder_name.substr(0, pos);
  96                 // number in string is in hex format, convert to int
  97                 suc_flg = string_to_number<int>(family_code, tmp_str, hex);
  98                 // if family code = 0x81 (1-wire usb dongle), do not try to create the device
  99                 if (family_code != 0x81) {
 100                         if (suc_flg == true) {
 101                                 log_debug("1-wire device family code: %#x\n", family_code);
 102                                 device_name     = folder_name.substr(pos + 1, folder_name.length() - pos);
 103                                 ret_val         = Factory::get_device(family_code,
 104                                                                 device_name,
 105                                                                 direntry_param);
 106                                 if ((ret_val == NULL) &&
 107                                     (family_code != 0x81)) {
 108                                         *err_code_param = 1;
 109                                 }
 110                         }
 111                 }
 112         }
 113         return ret_val;
 114 }
 115
 116 list<W1Device *> Factory::get_device_list() {
 117         DIR                     *dir;
 118         int                     err_flg;
 119         struct dirent           *direntry;
 120         W1Device                *device;
 121         bool                    is_subdir;
 122         list<W1Device *>        ret_val;
 123
 124         dir     = opendir(W1_SCAN_ROOTDIR);
 125         if (dir != NULL) {
 126                 direntry        = readdir(dir);
 127                 while(direntry != NULL) {
 128                         is_subdir       = W1Util::is_subdirectory(W1_SCAN_ROOTDIR, direntry);
 129                         if (is_subdir == true) {
 130                                 err_flg = 0;
 131                                 device  = create_device(direntry, &err_flg);
 132                                 if (device != NULL) {
 133                                         ret_val.push_back(device);
 134                                 }
 135                                 else {
 136                                         if (err_flg != 0) {
 137                                                 log_info("Unsupported 1-wire device detected: %s\n", direntry->d_name);
 138                                         }
 139                                 }
 140                         }
 141                         direntry        = readdir(dir);
 142                 }
 143                 err_flg = closedir(dir);
 144                 if (err_flg < 0) {
 145                         log_error("Failed to close 1-wire device directory: %s\n", W1_SCAN_ROOTDIR);
 146                 }
 147         }
 148         return ret_val;
 149 }
 150
 151 list<DeviceData *> Factory::get_device_data_list() {
 152         DIR                     *dir;
 153         string                  dr_name;
 154         int                     err_flg;
 155         struct dirent           *direntry;
 156         DeviceData              *dev_dta;
 157         bool                    is_subdir;
 158         list<DeviceData *>      ret_val;
 159
 160         dr_name = DeviceConfig::get_base_dir_name();
 161         dir     = opendir(dr_name.c_str());
 162         if (dir != NULL) {
 163                 direntry        = readdir(dir);
 164                 while(direntry != NULL) {
 165                         if (strcmp(direntry->d_name, "cache") != 0) {
 166                                 is_subdir       = W1Util::is_subdirectory(dr_name.c_str(), direntry);
 167                                 if (is_subdir == true) {
 168                                         dev_dta = new DeviceData(direntry->d_name);
 169                                         ret_val.push_back(dev_dta);
 170                                 }
 171                         }
 172                         direntry        = readdir(dir);
 173                 }
 174                 err_flg = closedir(dir);
 175                 if (err_flg < 0) {
 176                         log_error("Failed to close 1-wire device data directory: %s\n", dr_name.c_str());
 177                 }
 178         }
 179         return ret_val;
 180 }
 181
 182 DeviceConfig *Factory::get_device_config(string device_id) {
 183         DeviceConfig    *ret_val;
 184
 185         ret_val = new DeviceConfig(device_id);
 186         return ret_val;
 187 }