class OnappMarket::API::Serializable

# File lib/onapp_market/api/serialize.rb, line 123
def self.attr_accessor(*vars)
  @attributes ||= []
  @attributes.concat vars
  super(*vars)
end

# File lib/onapp_market/api/serialize.rb, line 155
def self.attr_reader(*vars)
  @attributes ||= []
  @attributes.concat vars
  super(*vars)
end

# File lib/onapp_market/api/serialize.rb, line 133
def self.attributes
  @attributes ||= []
  # Our local attributes
  attrs = @attributes
  # Merge in our parent attributes
  attrs.concat(superclass.attributes) if superclass.ancestors.include? Serializable and superclass.attributes != nil
  # Remove duplicates
  attrs.uniq if attrs != nil
end

# File lib/onapp_market/api/serialize.rb, line 194
def self.get_all_accessors(role = :all)
  begin
    obj = self.new
    # Does rails exists
    is_market = true
    begin
      OnappMarketService
    rescue
      is_market = false
    end
    result  = self.attributes.reject do |attr|
      true if ([:accessors, :api].include? attr) or (is_market and obj.accessors.include?(attr) and !obj.accessors[attr].include?(role) and role != :all)
    end
    return result
  #rescue
  #  raise "Could not get accessors for type #{self}"
  end
  return []
end

# File lib/onapp_market/api/serialize.rb, line 80
def self.index(symbol, type)
  @indexes ||= {}
  @indexes[symbol] = type
end

# File lib/onapp_market/api/serialize.rb, line 102
def self.indexes
  # Our local attributes
  indexes = @indexes
  indexes ||= {}
  # Merge in our parent attributes
  indexes = indexes.merge(superclass.indexes) if superclass.ancestors.include? Serializable and superclass.indexes != nil
  indexes
end

# File lib/onapp_market/api/serialize.rb, line 71
def self.int_indexes(*vars)
  vars.each { |v| self.index(v, INT_INDEX)}
end

# File lib/onapp_market/api/serialize.rb, line 91
def self.method_missing(sym_method, *args, &block)
  @related ||= {}
  return @related[sym_method] if args.count == 0
  return @related[sym_method] = args[0] if args.count == 1
  raise "OnappMarket::API::Serializable#method_missing - Incorrect number of arguments #{args.count} [#{args.inspect}]"
end

# File lib/onapp_market/api/serialize.rb, line 37
def self.namespace
  self::TYPE
end

# File lib/onapp_market/api/serialize.rb, line 17
def initialize(hash = {}, type = nil)
  raise "No type defined for Serializable class" if type == nil
  # Set the type
  @type = type
  # Restricted accessors
  @accessors = {}
  # Write all values from the hash
  hash.map do |(k, v)| 
    writer_m = "#{k}="
    send(writer_m, v) if respond_to?(writer_m) 
  end
  # Process block if provided
  yield self if block_given?
end

# File lib/onapp_market/api/serialize.rb, line 63
def self.string_indexes(*vars)
  vars.each { |v| self.index(v, STRING_INDEX)}
end

# File lib/onapp_market/api/serialize.rb, line 41
def accessors
  @accessors
end

# File lib/onapp_market/api/serialize.rb, line 147
def attributes
  self.class.attributes
end

# File lib/onapp_market/api/serialize.rb, line 218
def get_accessors(role)
  # Does rails exists
  is_market = true
  begin
    OnappMarketService
  rescue
    is_market = false
  end
  # Build array map on all instance variables
  array = Array(self.instance_variables.map { |name| name = name.to_s[1..-1].to_sym }).reject do |accessor|
    # Filter out :accessors & :api and also any accessors restricted for which the role is not present
    # We only do this is Rails is present - i.e. server side. It is meaningless client side.
    true if ([:accessors, :api].include? accessor) or (is_market and @accessors.include?(accessor) and !@accessors[accessor].include?(role) and role != :all)
  end
end

# File lib/onapp_market/api/serialize.rb, line 115
def indexes
  self.class.indexes
end

# File lib/onapp_market/api/serialize.rb, line 166
def require(*args)
  required = []
  # Always exclude these
  exclude = [:accessors, :api, :db_id]
  args.each do |arg|
    arg, value = arg.shift if arg.is_a? Hash
    case arg
      # Add all attributes
    when :all
      required = attributes
      # Add attributes to the list of exclusions
    when :exclude
      exclude = (value.is_a?(Array) ? exclude.concat(value) : exclude.push(value)) unless value == nil
    else
      # Push the attribute to the required list
      required.push(arg)
    end
  end
  not_present = []
  # Create the not present list (removing anything on the exclude list)
  required.each { |v| not_present.push(v) if !self.instance_variable_defined?("@#{v.to_s}") and !exclude.include? v }
  not_present
end

# File lib/onapp_market/api/serialize.rb, line 53
def restrict(symbol, roles)
  symbol = [symbol] unless symbol.is_a? Array
  roles = [roles] unless roles.is_a? Array
  symbol.each {|x| @accessors[x] = roles}
end