#include "verbly.h"
#include <set>
#include <iostream>

namespace verbly {
  
  noun::noun()
  {
    
  }
  
  noun::noun(const data& _data, int _id) : word(_data, _id)
  {
    
  }
  
  std::string noun::base_form() const
  {
    assert(_valid == true);
    
    return _singular;
  }

  std::string noun::singular_form() const
  {
    assert(_valid == true);
    
    return _singular;
  }
  
  std::string noun::plural_form() const
  {
    assert(_valid == true);
    
    return _plural;
  }
  
  int noun::wnid() const
  {
    assert(_valid == true);
    
    return _wnid;
  }

  bool noun::has_plural_form() const
  {
    assert(_valid == true);
    
    return !_plural.empty();
  }
  
  noun_query noun::hypernyms() const
  {
    assert(_valid == true);
    
    return _data->nouns().hypernym_of(*this);
  }
  
  noun_query noun::full_hypernyms() const
  {
    assert(_valid == true);
    
    return _data->nouns().full_hypernym_of(*this);
  }
  
  noun_query noun::hyponyms() const
  {
    assert(_valid == true);
    
    return _data->nouns().hyponym_of(*this);
  }
  
  noun_query noun::full_hyponyms() const
  {
    assert(_valid == true);
    
    return _data->nouns().full_hyponym_of(*this);
  }
  
  noun_query noun::part_meronyms() const
  {
    assert(_valid == true);
    
    return _data->nouns().part_meronym_of(*this);
  }
  
  noun_query noun::full_part_meronyms() const
  {
    assert(_valid == true);
    
    return _data->nouns().full_part_meronym_of(*this);
  }
  
  noun_query noun::part_holonyms() const
  {
    assert(_valid == true);
    
    return _data->nouns().part_holonym_of(*this);
  }
  
  noun_query noun::full_part_holonyms() const
  {
    assert(_valid == true);
    
    return _data->nouns().full_part_holonym_of(*this);
  }
  
  noun_query noun::substance_meronyms() const
  {
    assert(_valid == true);
    
    return _data->nouns().substance_meronym_of(*this);
  }
  
  noun_query noun::full_substance_meronyms() const
  {
    assert(_valid == true);
    
    return _data->nouns().full_substance_meronym_of(*this);
  }
  
  noun_query noun::substance_holonyms() const
  {
    assert(_valid == true);
    
    return _data->nouns().substance_holonym_of(*this);
  }
  
  noun_query noun::full_substance_holonyms() const
  {
    assert(_valid == true);
    
    return _data->nouns().full_substance_holonym_of(*this);
  }
  
  noun_query noun::member_meronyms() const
  {
    assert(_valid == true);
    
    return _data->nouns().member_meronym_of(*this);
  }
  
  noun_query noun::full_member_meronyms() const
  {
    assert(_valid == true);
    
    return _data->nouns().full_member_meronym_of(*this);
  }
  
  noun_query noun::member_holonyms() const
  {
    assert(_valid == true);
    
    return _data->nouns().member_holonym_of(*this);
  }
  
  noun_query noun::full_member_holonyms() const
  {
    assert(_valid == true);
    
    return _data->nouns().full_member_holonym_of(*this);
  }
  
  noun_query noun::classes() const
  {
    assert(_valid == true);
    
    return _data->nouns().class_of(*this);
  }
  
  noun_query noun::instances() const
  {
    assert(_valid == true);
    
    return _data->nouns().instance_of(*this);
  }
  
  noun_query noun::synonyms() const
  {
    assert(_valid == true);
    
    return _data->nouns().synonym_of(*this);
  }
  
  noun_query noun::antonyms() const
  {
    assert(_valid == true);
    
    return _data->nouns().antonym_of(*this);
  }
  
  adjective_query noun::pertainyms() const
  {
    assert(_valid == true);
    
    return _data->adjectives().pertainym_of(*this);
  }
  
  adjective_query noun::variations() const
  {
    assert(_valid == true);
    
    return _data->adjectives().variant_of(*this);
  }
  
  std::string noun::imagenet_url() const
  {
    std::stringstream url;
    url << "http://www.image-net.org/api/text/imagenet.synset.geturls?wnid=n";
    url.width(8);
    url.fill('0');
    url << (_wnid % 100000000);
    return url.str();
  }
  
  bool noun::operator<(const noun& other) const
  {
    return _id < other._id;
  }

};