oraclebmc 1.1.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 618bdb3d3d05f50343ba3ec7f8fc0088a4e76e74
-  data.tar.gz: bf6a43fc1c10492b661167faf7a92f06cf5e0e97
+  metadata.gz: e4b6f055fd6a44f614362a59b5da331ffdaa45b8
+  data.tar.gz: 47a1b20e3a7646f7eb6851450a3ee8c417ab7ce3
 SHA512:
-  metadata.gz: c2cde2ee5b5c23b1450e59a537328a8cc0aa522e19f36a78a1134724e4cad75b9a379f6f1c0f4b89be47a4c4a76334e4037fc01eeb79a705cc861690c8c7122c
-  data.tar.gz: 1cf7d1c087d69c7abe12933ffe5d42c75a822da2bb68ad3b35df70b3160b297ae80ad9866080e36b6bae7a4e976a87837d4297e9a4db5edd340d5587cd1c9a8e
+  metadata.gz: da5eabdc021b20d0be6a294c183237ae30fa1269a861582a415b1968979d8fc0f6b49eae4988549048b6a8cb20cd17eafa232162a50ba7caac62e78fec3527be
+  data.tar.gz: ddb0459abf040a768c1637addb2c55868f5be818cfe0139bd2c6d3de38421acb62a0ef155a48edf91faef536258141035d85c764b659d114f5933931c8e4c87c

data/LICENSE.txt

@@ -3,7 +3,7 @@ Copyright (c) 2016, 2017, Oracle and/or its affiliates.  All rights reserved.
 This software is dual-licensed to you under the Universal Permissive License (UPL) and Apache License 2.0.  See below for license terms.  You may choose either license, or both.
  ____________________________
 The Universal Permissive License (UPL), Version 1.0
-Copyright (c) 2016, Oracle and/or its affiliates.  All rights reserved.
+Copyright (c) 2016, 2017, Oracle and/or its affiliates.  All rights reserved.
 
 Subject to the condition set forth below, permission is hereby granted to any person obtaining a copy of this software, associated documentation and/or data (collectively the "Software"), free of charge and under any and all copyright rights in the Software, and any and all patent rights owned or freely licensable by each licensor hereunder covering either (i) the unmodified Software as contributed to or provided by such licensor, or (ii) the Larger Works (as defined below), to deal in both
 
@@ -19,7 +19,7 @@ The above copyright notice and either this complete permission notice or at a mi
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 The Apache Software License, Version 2.0
-Copyright (c) 2016, Oracle and/or its affiliates.  All rights reserved.
+Copyright (c) 2016, 2017, Oracle and/or its affiliates.  All rights reserved.
 
 Licensed under the Apache License, Version 2.0 (the "License"); You may not use this product except in compliance with the License.  You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.  A copy of the license is also reproduced below.  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the License for the specific language governing permissions and  limitations under the License.
 

data/README.md

@@ -1,5 +1,5 @@
 # Oracle Bare Metal Cloud Services Ruby SDK
-**Version 1.1.2**
+**Version 1.2.0**
 
 This topic describes how to install, configure, and use the Oracle Bare Metal Cloud Services Ruby SDK.
 
@@ -77,7 +77,7 @@ You can also [download the SDK](https://docs.us-phoenix-1.oraclecloud.com/tools/
  Install the gem with the following command:
  
 
- `gem install oraclebmc-1.1.2.gem`
+ `gem install oraclebmc-1.2.0.gem`
 
 
 The SDK depends on `libcurl`, which may need to be installed or upgraded on some operating systems to be compatible with Oracle Bare Metal Cloud Services. 

data/lib/oraclebmc/api_client.rb

@@ -248,56 +248,7 @@ module OracleBMC
         end
       end
 
-      convert_to_type data, return_type
-    end
-
-    # Convert reponse data to the given return type
-    # (for example, data:"15", return_type:"Integer" => 15).
-    #
-    # @param [Object] data Data to be converted
-    # @param [String] return_type Return type
-    # @return [Mixed] Data in a particular type
-    def convert_to_type(data, return_type)
-      return nil if data.nil?
-      case return_type
-      when 'String'
-        data.to_s
-      when 'Integer'
-        data.to_i
-      when 'Float'
-        data.to_f
-      when 'BOOLEAN'
-        data == true
-      when 'DateTime'
-        # parse date time (expecting ISO 8601 format)
-        DateTime.parse data
-      when 'Date'
-        # parse date time (expecting ISO 8601 format)
-        Date.parse data
-      when 'Object'
-        # generic object (usually a Hash), return directly
-        data
-      when /\AArray<(.+)>\z/
-        # e.g. Array<Pet>
-        sub_type = $1
-        data.map {|item| convert_to_type(item, sub_type) }
-      when /\AHash\<String, (.+)\>\z/
-        # e.g. Hash<String, Integer>
-        sub_type = $1
-        {}.tap do |hash|
-          data.each {|k, v| hash[k] = convert_to_type(v, sub_type) }
-        end
-      else
-        if defined? OracleBMC.const_get(return_type).get_subtype
-          # The return type may be an abstract type, in which case
-          # we need to use the discriminator value to get the correct subtype.
-          return_type = OracleBMC.const_get(return_type).get_subtype(data)
-        end
-
-        OracleBMC.const_get(return_type).new.tap do |model|
-          model.build_from_hash data
-        end
-      end
+      OracleBMC::Internal::Util.convert_to_type return_type, data
     end
 
     def build_request_url(path, endpoint)

data/lib/oraclebmc/core/compute_client.rb

@@ -470,6 +470,39 @@ module OracleBMC
         :return_type => 'OracleBMC::Core::Models::VolumeAttachment')
     end
 
+    # Gets the generated credentials for the instance. Only works for Windows instances. The returned credentials
+    # are only valid for the initial login.
+    # 
+    # @param [String] instance_id The OCID of the instance.
+    # @param [Hash] opts the optional parameters
+    # @return [Response] A Response object with data of type OracleBMC::Core::Models::InstanceCredentials
+    def get_windows_instance_initial_credentials(instance_id, opts = {})
+      logger.debug "Calling operation ComputeClient#get_windows_instance_initial_credentials." if logger
+
+      fail "Missing the required parameter 'instance_id' when calling get_windows_instance_initial_credentials." if instance_id.nil?
+
+      path = "/instances/{instanceId}/initialCredentials".sub('{instanceId}', instance_id.to_s)
+
+      # Query Params
+      query_params = {}
+
+      # Header Params
+      header_params = {}
+      header_params['accept'] = 'application/json'
+      header_params['content-type'] = 'application/json'
+
+      post_body = nil
+
+      return @api_client.call_api(
+        :GET,
+        path,
+        endpoint,
+        :header_params => header_params,
+        :query_params => query_params,
+        :body => post_body,
+        :return_type => 'OracleBMC::Core::Models::InstanceCredentials')
+    end
+
     # Performs one of the power actions (start, stop, softreset, or reset)
     # on the specified instance.
     # 

data/lib/oraclebmc/core/core.rb

@@ -29,6 +29,7 @@ require 'oraclebmc/core/models/create_volume_details'
 require 'oraclebmc/core/models/dhcp_dns_option'
 require 'oraclebmc/core/models/dhcp_option'
 require 'oraclebmc/core/models/dhcp_options'
+require 'oraclebmc/core/models/dhcp_search_domain_option'
 require 'oraclebmc/core/models/drg'
 require 'oraclebmc/core/models/drg_attachment'
 require 'oraclebmc/core/models/egress_security_rule'
@@ -40,6 +41,7 @@ require 'oraclebmc/core/models/icmp_options'
 require 'oraclebmc/core/models/image'
 require 'oraclebmc/core/models/ingress_security_rule'
 require 'oraclebmc/core/models/instance'
+require 'oraclebmc/core/models/instance_credentials'
 require 'oraclebmc/core/models/internet_gateway'
 require 'oraclebmc/core/models/launch_instance_details'
 require 'oraclebmc/core/models/port_range'

data/lib/oraclebmc/core/models/attach_i_scsi_volume_details.rb

@@ -63,10 +63,10 @@ module OracleBMC
           # check to ensure the input is an array given that the the attribute
           # is documented as an array but the input is not
           if attributes[self.class.attribute_map[key]].is_a?(Array)
-            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OracleBMC::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+          self.send("#{key}=", OracleBMC::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
         end # or else data not found in attributes(hash), not an issue as the data can be optional
       end
 
@@ -111,47 +111,6 @@ module OracleBMC
       end
     end
 
-    # Deserializes the data based on type
-    # @param [String] type Data type
-    # @param [String] value Value to be deserialized
-    # @return [Object] Deserialized data
-    def _deserialize(type, value)
-      case type.to_sym
-      when :DateTime
-        DateTime.parse(value)
-      when :Date
-        Date.parse(value)
-      when :String
-        value.to_s
-      when :Integer
-        value.to_i
-      when :Float
-        value.to_f
-      when :BOOLEAN
-        if value.to_s =~ /^(true|t|yes|y|1)$/i
-          true
-        else
-          false
-        end
-      when :Object
-        # generic object (usually a Hash), return directly
-        value
-      when /\AArray<(?<inner_type>.+)>\z/
-        inner_type = Regexp.last_match[:inner_type]
-        value.map { |v| _deserialize(inner_type, v) }
-      when /\AHash<(?<k_type>.+), (?<v_type>.+)>\z/
-        k_type = Regexp.last_match[:k_type]
-        v_type = Regexp.last_match[:v_type]
-        {}.tap do |hash|
-          value.each do |k, v|
-            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
-          end
-        end
-      else # model
-        temp_model = OracleBMC.const_get(type.to_s).new
-        temp_model.build_from_hash(value)
-      end
-    end
 
 
     # Attribute mapping from ruby-style variable name to JSON key.

data/lib/oraclebmc/core/models/attach_volume_details.rb

@@ -93,10 +93,10 @@ module OracleBMC
           # check to ensure the input is an array given that the the attribute
           # is documented as an array but the input is not
           if attributes[self.class.attribute_map[key]].is_a?(Array)
-            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OracleBMC::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+          self.send("#{key}=", OracleBMC::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
         end # or else data not found in attributes(hash), not an issue as the data can be optional
       end
 
@@ -141,47 +141,6 @@ module OracleBMC
       end
     end
 
-    # Deserializes the data based on type
-    # @param [String] type Data type
-    # @param [String] value Value to be deserialized
-    # @return [Object] Deserialized data
-    def _deserialize(type, value)
-      case type.to_sym
-      when :DateTime
-        DateTime.parse(value)
-      when :Date
-        Date.parse(value)
-      when :String
-        value.to_s
-      when :Integer
-        value.to_i
-      when :Float
-        value.to_f
-      when :BOOLEAN
-        if value.to_s =~ /^(true|t|yes|y|1)$/i
-          true
-        else
-          false
-        end
-      when :Object
-        # generic object (usually a Hash), return directly
-        value
-      when /\AArray<(?<inner_type>.+)>\z/
-        inner_type = Regexp.last_match[:inner_type]
-        value.map { |v| _deserialize(inner_type, v) }
-      when /\AHash<(?<k_type>.+), (?<v_type>.+)>\z/
-        k_type = Regexp.last_match[:k_type]
-        v_type = Regexp.last_match[:v_type]
-        {}.tap do |hash|
-          value.each do |k, v|
-            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
-          end
-        end
-      else # model
-        temp_model = OracleBMC.const_get(type.to_s).new
-        temp_model.build_from_hash(value)
-      end
-    end
 
 
     # Attribute mapping from ruby-style variable name to JSON key.

data/lib/oraclebmc/core/models/capture_console_history_details.rb

@@ -54,10 +54,10 @@ module OracleBMC
           # check to ensure the input is an array given that the the attribute
           # is documented as an array but the input is not
           if attributes[self.class.attribute_map[key]].is_a?(Array)
-            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OracleBMC::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+          self.send("#{key}=", OracleBMC::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
         end # or else data not found in attributes(hash), not an issue as the data can be optional
       end
 
@@ -102,47 +102,6 @@ module OracleBMC
       end
     end
 
-    # Deserializes the data based on type
-    # @param [String] type Data type
-    # @param [String] value Value to be deserialized
-    # @return [Object] Deserialized data
-    def _deserialize(type, value)
-      case type.to_sym
-      when :DateTime
-        DateTime.parse(value)
-      when :Date
-        Date.parse(value)
-      when :String
-        value.to_s
-      when :Integer
-        value.to_i
-      when :Float
-        value.to_f
-      when :BOOLEAN
-        if value.to_s =~ /^(true|t|yes|y|1)$/i
-          true
-        else
-          false
-        end
-      when :Object
-        # generic object (usually a Hash), return directly
-        value
-      when /\AArray<(?<inner_type>.+)>\z/
-        inner_type = Regexp.last_match[:inner_type]
-        value.map { |v| _deserialize(inner_type, v) }
-      when /\AHash<(?<k_type>.+), (?<v_type>.+)>\z/
-        k_type = Regexp.last_match[:k_type]
-        v_type = Regexp.last_match[:v_type]
-        {}.tap do |hash|
-          value.each do |k, v|
-            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
-          end
-        end
-      else # model
-        temp_model = OracleBMC.const_get(type.to_s).new
-        temp_model.build_from_hash(value)
-      end
-    end
 
 
     # Attribute mapping from ruby-style variable name to JSON key.

data/lib/oraclebmc/core/models/console_history.rb

@@ -132,10 +132,10 @@ module OracleBMC
           # check to ensure the input is an array given that the the attribute
           # is documented as an array but the input is not
           if attributes[self.class.attribute_map[key]].is_a?(Array)
-            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OracleBMC::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+          self.send("#{key}=", OracleBMC::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
         end # or else data not found in attributes(hash), not an issue as the data can be optional
       end
 
@@ -180,47 +180,6 @@ module OracleBMC
       end
     end
 
-    # Deserializes the data based on type
-    # @param [String] type Data type
-    # @param [String] value Value to be deserialized
-    # @return [Object] Deserialized data
-    def _deserialize(type, value)
-      case type.to_sym
-      when :DateTime
-        DateTime.parse(value)
-      when :Date
-        Date.parse(value)
-      when :String
-        value.to_s
-      when :Integer
-        value.to_i
-      when :Float
-        value.to_f
-      when :BOOLEAN
-        if value.to_s =~ /^(true|t|yes|y|1)$/i
-          true
-        else
-          false
-        end
-      when :Object
-        # generic object (usually a Hash), return directly
-        value
-      when /\AArray<(?<inner_type>.+)>\z/
-        inner_type = Regexp.last_match[:inner_type]
-        value.map { |v| _deserialize(inner_type, v) }
-      when /\AHash<(?<k_type>.+), (?<v_type>.+)>\z/
-        k_type = Regexp.last_match[:k_type]
-        v_type = Regexp.last_match[:v_type]
-        {}.tap do |hash|
-          value.each do |k, v|
-            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
-          end
-        end
-      else # model
-        temp_model = OracleBMC.const_get(type.to_s).new
-        temp_model.build_from_hash(value)
-      end
-    end
 
 
     # Attribute mapping from ruby-style variable name to JSON key.

data/lib/oraclebmc/core/models/cpe.rb

@@ -93,10 +93,10 @@ module OracleBMC
           # check to ensure the input is an array given that the the attribute
           # is documented as an array but the input is not
           if attributes[self.class.attribute_map[key]].is_a?(Array)
-            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OracleBMC::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+          self.send("#{key}=", OracleBMC::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
         end # or else data not found in attributes(hash), not an issue as the data can be optional
       end
 
@@ -141,47 +141,6 @@ module OracleBMC
       end
     end
 
-    # Deserializes the data based on type
-    # @param [String] type Data type
-    # @param [String] value Value to be deserialized
-    # @return [Object] Deserialized data
-    def _deserialize(type, value)
-      case type.to_sym
-      when :DateTime
-        DateTime.parse(value)
-      when :Date
-        Date.parse(value)
-      when :String
-        value.to_s
-      when :Integer
-        value.to_i
-      when :Float
-        value.to_f
-      when :BOOLEAN
-        if value.to_s =~ /^(true|t|yes|y|1)$/i
-          true
-        else
-          false
-        end
-      when :Object
-        # generic object (usually a Hash), return directly
-        value
-      when /\AArray<(?<inner_type>.+)>\z/
-        inner_type = Regexp.last_match[:inner_type]
-        value.map { |v| _deserialize(inner_type, v) }
-      when /\AHash<(?<k_type>.+), (?<v_type>.+)>\z/
-        k_type = Regexp.last_match[:k_type]
-        v_type = Regexp.last_match[:v_type]
-        {}.tap do |hash|
-          value.each do |k, v|
-            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
-          end
-        end
-      else # model
-        temp_model = OracleBMC.const_get(type.to_s).new
-        temp_model.build_from_hash(value)
-      end
-    end
 
 
     # Attribute mapping from ruby-style variable name to JSON key.

data/lib/oraclebmc/core/models/create_cpe_details.rb

@@ -75,10 +75,10 @@ module OracleBMC
           # check to ensure the input is an array given that the the attribute
           # is documented as an array but the input is not
           if attributes[self.class.attribute_map[key]].is_a?(Array)
-            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OracleBMC::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+          self.send("#{key}=", OracleBMC::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
         end # or else data not found in attributes(hash), not an issue as the data can be optional
       end
 
@@ -123,47 +123,6 @@ module OracleBMC
       end
     end
 
-    # Deserializes the data based on type
-    # @param [String] type Data type
-    # @param [String] value Value to be deserialized
-    # @return [Object] Deserialized data
-    def _deserialize(type, value)
-      case type.to_sym
-      when :DateTime
-        DateTime.parse(value)
-      when :Date
-        Date.parse(value)
-      when :String
-        value.to_s
-      when :Integer
-        value.to_i
-      when :Float
-        value.to_f
-      when :BOOLEAN
-        if value.to_s =~ /^(true|t|yes|y|1)$/i
-          true
-        else
-          false
-        end
-      when :Object
-        # generic object (usually a Hash), return directly
-        value
-      when /\AArray<(?<inner_type>.+)>\z/
-        inner_type = Regexp.last_match[:inner_type]
-        value.map { |v| _deserialize(inner_type, v) }
-      when /\AHash<(?<k_type>.+), (?<v_type>.+)>\z/
-        k_type = Regexp.last_match[:k_type]
-        v_type = Regexp.last_match[:v_type]
-        {}.tap do |hash|
-          value.each do |k, v|
-            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
-          end
-        end
-      else # model
-        temp_model = OracleBMC.const_get(type.to_s).new
-        temp_model.build_from_hash(value)
-      end
-    end
 
 
     # Attribute mapping from ruby-style variable name to JSON key.

data/lib/oraclebmc/core/models/create_dhcp_details.rb

@@ -81,10 +81,10 @@ module OracleBMC
           # check to ensure the input is an array given that the the attribute
           # is documented as an array but the input is not
           if attributes[self.class.attribute_map[key]].is_a?(Array)
-            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OracleBMC::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+          self.send("#{key}=", OracleBMC::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
         end # or else data not found in attributes(hash), not an issue as the data can be optional
       end
 
@@ -129,47 +129,6 @@ module OracleBMC
       end
     end
 
-    # Deserializes the data based on type
-    # @param [String] type Data type
-    # @param [String] value Value to be deserialized
-    # @return [Object] Deserialized data
-    def _deserialize(type, value)
-      case type.to_sym
-      when :DateTime
-        DateTime.parse(value)
-      when :Date
-        Date.parse(value)
-      when :String
-        value.to_s
-      when :Integer
-        value.to_i
-      when :Float
-        value.to_f
-      when :BOOLEAN
-        if value.to_s =~ /^(true|t|yes|y|1)$/i
-          true
-        else
-          false
-        end
-      when :Object
-        # generic object (usually a Hash), return directly
-        value
-      when /\AArray<(?<inner_type>.+)>\z/
-        inner_type = Regexp.last_match[:inner_type]
-        value.map { |v| _deserialize(inner_type, v) }
-      when /\AHash<(?<k_type>.+), (?<v_type>.+)>\z/
-        k_type = Regexp.last_match[:k_type]
-        v_type = Regexp.last_match[:v_type]
-        {}.tap do |hash|
-          value.each do |k, v|
-            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
-          end
-        end
-      else # model
-        temp_model = OracleBMC.const_get(type.to_s).new
-        temp_model.build_from_hash(value)
-      end
-    end
 
 
     # Attribute mapping from ruby-style variable name to JSON key.

data/lib/oraclebmc/core/models/create_drg_attachment_details.rb

@@ -72,10 +72,10 @@ module OracleBMC
           # check to ensure the input is an array given that the the attribute
           # is documented as an array but the input is not
           if attributes[self.class.attribute_map[key]].is_a?(Array)
-            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| OracleBMC::Internal::Util.convert_to_type($1, v) } )
           end
         elsif !attributes[self.class.attribute_map[key]].nil?
-          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+          self.send("#{key}=", OracleBMC::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]]))
         end # or else data not found in attributes(hash), not an issue as the data can be optional
       end
 
@@ -120,47 +120,6 @@ module OracleBMC
       end
     end
 
-    # Deserializes the data based on type
-    # @param [String] type Data type
-    # @param [String] value Value to be deserialized
-    # @return [Object] Deserialized data
-    def _deserialize(type, value)
-      case type.to_sym
-      when :DateTime
-        DateTime.parse(value)
-      when :Date
-        Date.parse(value)
-      when :String
-        value.to_s
-      when :Integer
-        value.to_i
-      when :Float
-        value.to_f
-      when :BOOLEAN
-        if value.to_s =~ /^(true|t|yes|y|1)$/i
-          true
-        else
-          false
-        end
-      when :Object
-        # generic object (usually a Hash), return directly
-        value
-      when /\AArray<(?<inner_type>.+)>\z/
-        inner_type = Regexp.last_match[:inner_type]
-        value.map { |v| _deserialize(inner_type, v) }
-      when /\AHash<(?<k_type>.+), (?<v_type>.+)>\z/
-        k_type = Regexp.last_match[:k_type]
-        v_type = Regexp.last_match[:v_type]
-        {}.tap do |hash|
-          value.each do |k, v|
-            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
-          end
-        end
-      else # model
-        temp_model = OracleBMC.const_get(type.to_s).new
-        temp_model.build_from_hash(value)
-      end
-    end
 
 
     # Attribute mapping from ruby-style variable name to JSON key.