m2mbase_stub.cpp

00001 /*
00002  * Copyright (c) 2015 ARM Limited. All rights reserved.
00003  * SPDX-License-Identifier: Apache-2.0
00004  * Licensed under the Apache License, Version 2.0 (the License); you may
00005  * not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  * http://www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an AS IS BASIS, WITHOUT
00012  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 #include "m2mbase_stub.h"
00017 
00018 #include <assert.h>
00019 
00020 uint8_t m2mbase_stub::uint8_value;
00021 uint16_t m2mbase_stub::uint16_value;
00022 uint32_t m2mbase_stub::uint32_value;
00023 uint16_t m2mbase_stub::int_value;
00024 int32_t m2mbase_stub::name_id_value;
00025 
00026 bool m2mbase_stub::bool_value;
00027 String *m2mbase_stub::string_value;
00028 
00029 M2MBase::BaseType m2mbase_stub::base_type;
00030 M2MBase::Operation m2mbase_stub::operation;
00031 M2MBase::Mode m2mbase_stub::mode_value;
00032 M2MBase::Observation m2mbase_stub::observation_level_value;
00033 
00034 void *m2mbase_stub::void_value;
00035 M2MObservationHandler *m2mbase_stub::observe;
00036 M2MReportHandler *m2mbase_stub::report;
00037 bool m2mbase_stub::is_value_updated_function_set;
00038 
00039 
00040 void m2mbase_stub::clear()
00041 {
00042     int_value = 0;
00043     uint8_value = 0;
00044     uint16_value = 0;
00045     uint32_value = 0;
00046     string_value = NULL;
00047     name_id_value = -1;
00048     mode_value = M2MBase::Static;
00049     base_type = M2MBase::Object;
00050     observation_level_value = M2MBase::None;
00051     bool_value = false;
00052     m2mbase_stub::operation = M2MBase::NOT_ALLOWED;
00053     void_value = NULL;
00054     observe = NULL;
00055     report = NULL;
00056     is_value_updated_function_set = false;
00057 }
00058 
00059 M2MBase::M2MBase(const String &/*resource_name*/,
00060                  M2MBase::Mode /*mode*/)
00061 {
00062 }
00063 
00064 M2MBase& M2MBase::operator=(const M2MBase& other)
00065 {
00066     if (this != &other) { // protect against invalid self-assignment
00067     }
00068     return *this;
00069 }
00070 
00071 M2MBase::M2MBase(const M2MBase& other)
00072 {
00073     this->operator=(other);
00074 }
00075 
00076 M2MBase::~M2MBase()
00077 {
00078 }
00079 
00080 void M2MBase::set_operation(M2MBase::Operation opr)
00081 {
00082     m2mbase_stub::operation = opr;
00083 }
00084 
00085 void M2MBase::set_interface_description(const String &/*desc*/)
00086 {
00087 }
00088 
00089 void M2MBase::set_resource_type(const String &/*res_type*/)
00090 {
00091 }
00092 
00093 void M2MBase::set_coap_content_type(const uint8_t /*con_type*/)
00094 {
00095 }
00096 
00097 void M2MBase::set_instance_id(const uint16_t /*inst_id*/)
00098 {
00099 }
00100 
00101 void M2MBase::set_observation_number(const uint16_t /*observation_number*/)
00102 {
00103 }
00104 
00105 void M2MBase::set_max_age(const uint32_t /*max_age*/)
00106 {
00107 }
00108 
00109 M2MBase::Operation M2MBase::operation() const
00110 {
00111     return m2mbase_stub::operation;
00112 }
00113 
00114 const String& M2MBase::name() const
00115 {
00116     return *m2mbase_stub::string_value;
00117 }
00118 
00119 int32_t M2MBase::name_id() const
00120 {
00121     return m2mbase_stub::name_id_value;
00122 }
00123 
00124 uint16_t M2MBase::instance_id() const
00125 {
00126     return m2mbase_stub::int_value;
00127 }
00128 
00129 const String& M2MBase::interface_description() const
00130 {
00131     return *m2mbase_stub::string_value;
00132 }
00133 
00134 const String& M2MBase::resource_type() const
00135 {
00136     return *m2mbase_stub::string_value;
00137 }
00138 
00139 uint8_t M2MBase::coap_content_type() const
00140 {
00141     return m2mbase_stub::uint8_value;
00142 }
00143 
00144 uint32_t M2MBase::max_age() const
00145 {
00146     return m2mbase_stub::uint32_value;
00147 }
00148 
00149 void M2MBase::set_observable(bool /*observable*/)
00150 {
00151 }
00152 
00153 void M2MBase::add_observation_level(M2MBase::Observation)
00154 {
00155 }
00156 
00157 void M2MBase::remove_observation_level(M2MBase::Observation)
00158 {
00159 }
00160 
00161 void M2MBase::set_under_observation(bool /*observed*/,
00162                                    M2MObservationHandler */*handler*/)
00163 {
00164 }
00165 
00166 void M2MBase::set_observation_token(const uint8_t */*token*/,
00167                                     const uint8_t /*length*/)
00168 {
00169 }
00170 
00171 bool M2MBase::is_observable() const
00172 {
00173     return m2mbase_stub::bool_value;
00174 }
00175 
00176 M2MBase::Observation M2MBase::observation_level() const
00177 {
00178     return m2mbase_stub::observation_level_value;
00179 }
00180 
00181 void M2MBase::get_observation_token(uint8_t *&/*token*/,
00182                                     uint32_t &/*length*/)
00183 {
00184 }
00185 
00186 void M2MBase::set_base_type(M2MBase::BaseType /*type*/)
00187 {
00188 }
00189 
00190 M2MBase::BaseType M2MBase::base_type() const
00191 {
00192     return m2mbase_stub::base_type;
00193 }
00194 
00195 M2MBase::Mode M2MBase::mode() const
00196 {
00197     return m2mbase_stub::mode_value;
00198 }
00199 
00200 uint16_t M2MBase::observation_number() const
00201 {
00202     return m2mbase_stub::uint16_value;
00203 }
00204 
00205 void M2MBase::remove_resource_from_coap(const String &)
00206 {
00207 }
00208 
00209 void M2MBase::remove_object_from_coap()
00210 {
00211 }
00212 
00213 bool M2MBase::handle_observation_attribute(char *&query)
00214 {
00215     return m2mbase_stub::bool_value;
00216 }
00217 
00218 void M2MBase::observation_to_be_sent(m2m::Vector<uint16_t>, bool)
00219 {
00220 }
00221 
00222 void *M2MBase::memory_alloc(uint32_t size)
00223 {
00224     if(size)
00225         return malloc(size);
00226     else
00227         return 0;
00228 }
00229 
00230 void M2MBase::memory_free(void *ptr)
00231 {
00232     if(ptr)
00233         free(ptr);
00234 }
00235 
00236 uint8_t* M2MBase::alloc_string_copy(const uint8_t* source, uint32_t size)
00237 {
00238     assert(source != NULL);
00239 
00240     uint8_t* result = (uint8_t*)memory_alloc(size + 1);
00241     if (result) {
00242         memcpy(result, source, size);
00243         result[size] = '\0';
00244     }
00245     return result;
00246 }
00247 
00248 uint8_t* M2MBase::alloc_copy(const uint8_t* source, uint32_t size)
00249 {
00250     assert(source != NULL);
00251 
00252     uint8_t* result = (uint8_t*)memory_alloc(size);
00253     if (result) {
00254         memcpy(result, source, size);
00255     }
00256     return result;
00257 }
00258 
00259 M2MReportHandler* M2MBase::report_handler()
00260 {
00261     return m2mbase_stub::report;
00262 }
00263 
00264 M2MObservationHandler* M2MBase::observation_handler()
00265 {
00266     return m2mbase_stub::observe;
00267 }
00268 
00269 sn_coap_hdr_s* M2MBase::handle_get_request(nsdl_s */*nsdl*/,
00270                                            sn_coap_hdr_s */*received_coap_header*/,
00271                                            M2MObservationHandler */*observation_handler*/)
00272 {
00273     //Handled in M2MResource, M2MObjectInstance and M2MObject classes
00274     return NULL;
00275 }
00276 
00277 sn_coap_hdr_s* M2MBase::handle_put_request(nsdl_s */*nsdl*/,
00278                                            sn_coap_hdr_s */*received_coap_header*/,
00279                                            M2MObservationHandler */*observation_handler*/,
00280                                            bool &execute_value_updated)
00281 {
00282     //Handled in M2MResource, M2MObjectInstance and M2MObject classes
00283     return NULL;
00284 }
00285 
00286 sn_coap_hdr_s* M2MBase::handle_post_request(nsdl_s */*nsdl*/,
00287                                             sn_coap_hdr_s */*received_coap_header*/,
00288                                             M2MObservationHandler */*observation_handler*/,
00289                                             bool &)
00290 {
00291     //Handled in M2MResource, M2MObjectInstance and M2MObject classes
00292     return NULL;
00293 }
00294 
00295 void M2MBase::set_register_uri( bool register_uri)
00296 {
00297 }
00298 
00299 bool M2MBase::register_uri()
00300 {
00301     return m2mbase_stub::bool_value;
00302 }
00303 
00304 void M2MBase::set_uri_path(const String &uri_path)
00305 {
00306 }
00307 
00308 const String& M2MBase::uri_path() const
00309 {
00310     return *m2mbase_stub::string_value;
00311 }
00312 
00313 bool M2MBase::is_under_observation() const
00314 {
00315     return m2mbase_stub::bool_value;
00316 }
00317 
00318 void M2MBase::set_value_updated_function(value_updated_callback  callback)
00319 {
00320 
00321 }
00322 
00323 void M2MBase::set_value_updated_function(value_updated_callback2 callback)
00324 {
00325 
00326 }
00327 
00328 bool M2MBase::is_value_updated_function_set()
00329 {
00330     return m2mbase_stub::is_value_updated_function_set;
00331 }
00332 
00333 void M2MBase::execute_value_updated(const String& name)
00334 {
00335 
00336 }