variable/equality.cpp

   1 #include <ail/exception.hpp>
   2 #include <fridh/symbol.hpp>
   3
   4 namespace fridh
   5 {
   6         bool variable::array_equality(variable const & other) const
   7         {
   8                 types::vector
   9                         & vector = *array,
  10                         & other_vector = *other.array;
  11
  12                 std::size_t size = vector.size();
  13                 if(size != vector.size())
  14                         return false;
  15
  16                 for(std::size_t i = 0; i < size; i++)
  17                 {
  18                         if(vector[i] != other_vector[i])
  19                                 return false;
  20                 }
  21
  22                 return true;
  23         }
  24
  25         bool variable::map_equality(variable const & other) const
  26         {
  27                 types::map
  28                         & this_map = *map,
  29                         & other_map = *other.map;
  30
  31                 if(this_map.size() != other_map.size())
  32                         return false;
  33
  34                 for(types::map::const_iterator i = this_map.begin(), end = this_map.end(); i != end; i++)
  35                 {
  36                         types::map::const_iterator iterator = other_map.find(i->first);
  37                         if(iterator == other_map.end())
  38                                 return false;
  39
  40                         if(i->second != iterator->second)
  41                                 return false;
  42                 }
  43
  44                 return true;
  45         }
  46
  47         bool variable::operator==(variable const & other) const
  48         {
  49                 if(is_numeric_type() && other.is_numeric_type())
  50                 {
  51                         if(type == variable_type_identifier::floating_point_value || other.type == variable_type_identifier::floating_point_value)
  52                                 return get_floating_point_value() == other.get_floating_point_value();
  53                         else
  54                                 return unsigned_integer == other.unsigned_integer;
  55                 }
  56                 else
  57                 {
  58                         switch(type)
  59                         {
  60                         case variable_type_identifier::nil:
  61                         case variable_type_identifier::none:
  62                                 return type == other.type;
  63                                 return type == other.type;
  64
  65                         case variable_type_identifier::boolean:
  66                                 return type == other.type && boolean == other.boolean;
  67
  68                         case variable_type_identifier::string:
  69                                 return type == other.type && *string == *other.string;
  70
  71                         case variable_type_identifier::array:
  72                                 return array_equality(other);
  73
  74                         case variable_type_identifier::map:
  75                                 return map_equality(other);
  76
  77                         case variable_type_identifier::function:
  78                                 throw ail::exception("Comparison of functions has not been implemented yet");
  79
  80                         case variable_type_identifier::object:
  81                                 throw ail::exception("Comparison of objects has not been implemented yet");
  82
  83                         case variable_type_identifier::signed_integer:
  84                         case variable_type_identifier::unsigned_integer:
  85                         case variable_type_identifier::floating_point_value:
  86                         default:
  87                                 return false;
  88                         }
  89                 }
  90         }
  91
  92         bool variable::operator!=(variable const & other) const
  93         {
  94                 return !operator==(other);
  95         }
  96 }