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
  46         ret_val = NULL;
  47         log_debug("family_code: %d\n", family_code);
  48         switch(family_code) {
  49                 case    0x10:
  50                 case    0x28:
  51                         ret_val = new W1TemperatureSensor(family_code, device_id, direntry_param);
  52                         log_debug("temperature sensor: %d\n", ret_val->get_family_code());
  53                         break;
  54                 case    0x1d:
  55                         ret_val = new W1CounterDevice(family_code, device_id, direntry_param);
  56                         log_debug("counter device: %d\n", family_code);
  57                         break;
  58                 default:
  59                         log_debug("device not created, unsupported device type: %d\n", family_code);
  60                         break;
  61         }
  62         if (ret_val != NULL) {
  63                 // check that device config exist
  64                 // if not, create default...
  65                 config  = get_device_config(device_id);
  66                 if (config != NULL) {
  67                         string  type;
  68                         type    = config->get_cfg_value(DEVICE_CONFIG_VALUE_KEY__TYPE);
  69                         if (type.empty() == true) {
  70                                 type    = ret_val->get_device_type();
  71                                 config->set_cfg_value(DEVICE_CONFIG_VALUE_KEY__TYPE, type);
  72                                 config->set_cfg_value(DEVICE_CONFIG_VALUE_KEY__ID, ret_val->get_id());
  73                         }
  74                 }
  75         }
  76         return ret_val;
  77 }
  78
  79 W1Device *Factory::create_device(dirent *direntry_param) {
  80         string          folder_name;
  81         string          tmp_str;
  82         string          device_name;
  83         int             pos;
  84         int             family_code;
  85         bool            suc_flg;
  86         W1Device        *ret_val;
  87
  88         ret_val         = NULL;
  89         folder_name     = direntry_param->d_name;
  90         pos             = folder_name.find("-");
  91         if (pos > 0) {
  92                 tmp_str = folder_name.substr(0, pos);
  93                 // number in string is in hex format, convert to int
  94                 suc_flg = string_to_number<int>(family_code, tmp_str, hex);
  95                 if (suc_flg == true) {
  96                         log_debug("family_code: %d\n", family_code);
  97                         device_name     = folder_name.substr(pos + 1, folder_name.length() - pos);
  98                         ret_val         = Factory::get_device(family_code,
  99                                                         device_name,
 100                                                         direntry_param);
 101                 }
 102         }
 103         return ret_val;
 104 }
 105
 106 list<W1Device *> Factory::get_device_list() {
 107         DIR                     *dir;
 108         int                     err_flg;
 109         struct dirent           *direntry;
 110         W1Device                *device;
 111         bool                    is_subdir;
 112         list<W1Device *>        ret_val;
 113
 114         printf("get_device_list() started\n");
 115         dir     = opendir(W1_SCAN_ROOTDIR);
 116         if (dir != NULL) {
 117                 direntry        = readdir(dir);
 118                 while(direntry != NULL) {
 119                         is_subdir       = W1Util::is_subdirectory(W1_SCAN_ROOTDIR, direntry);
 120                         if (is_subdir == true) {
 121                                 log_info("dir_name: %s\n", direntry->d_name);
 122                                 device  = create_device(direntry);
 123                                 if (device != NULL) {
 124                                         log_info("device: %d\n", device->get_family_code());
 125                                         ret_val.push_back(device);
 126                                 }
 127                                 else {
 128                                         log_info("unsupported device-directory: %s\n", direntry->d_name);
 129                                 }
 130                         }
 131                         direntry        = readdir(dir);
 132                 }
 133                 err_flg = closedir(dir);
 134                 if (err_flg < 0) {
 135                         log_error("failed to close 1-wire device directory: %s\n", W1_SCAN_ROOTDIR);
 136                 }
 137         }
 138         return ret_val;
 139 }
 140
 141 list<DeviceData *> Factory::get_device_data_list() {
 142         DIR                     *dir;
 143         string                  dr_name;
 144         int                     err_flg;
 145         struct dirent           *direntry;
 146         DeviceData              *dev_dta;
 147         bool                    is_subdir;
 148         list<DeviceData *>      ret_val;
 149
 150         printf("get_device_list() started\n");
 151         dr_name = DeviceConfig::get_base_dir_name();
 152         dir     = opendir(dr_name.c_str());
 153         if (dir != NULL) {
 154                 direntry        = readdir(dir);
 155                 while(direntry != NULL) {
 156                         if (strcmp(direntry->d_name, "cache") != 0) {
 157                                 is_subdir       = W1Util::is_subdirectory(dr_name.c_str(), direntry);
 158                                 if (is_subdir == true) {
 159                                         dev_dta = new DeviceData(direntry->d_name);
 160                                         log_info("dir_name: %s\n", direntry->d_name);
 161                                         ret_val.push_back(dev_dta);
 162                                 }
 163                         }
 164                         direntry        = readdir(dir);
 165                 }
 166                 err_flg = closedir(dir);
 167                 if (err_flg < 0) {
 168                         log_error("failed to close 1-wire device data directory: %s\n", dr_name.c_str());
 169                 }
 170         }
 171         return ret_val;
 172 }
 173
 174 DeviceConfig *Factory::get_device_config(string device_id) {
 175         DeviceConfig    *ret_val;
 176
 177         ret_val = new DeviceConfig(device_id);
 178         return ret_val;
 179 }