DictString/DictString.cpp at master · alkemyst/DictString · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
#include "DictString.h"

typedef DictString DS;

DS::dict_container DS::dict;
const DictString DS::emptyDictString("");

const DS::dict_iterator& DS::findIterator(const string& str) {
  const auto& myWord = dict.find(str);
  if (myWord != dict.end()) return myWord;
  // New word in dictionary
  auto newEntry = std::make_pair(str, dict.size());
  const DS::dict_iterator& insertedIterator = dict.insert(newEntry).first;
  return insertedIterator;
}

// findString for my index
const DS::string& DS::findString(const dict_iterator& i) {
  return i->first;
}

// Default constructor
DS::DictString() {
  (*this) = emptyDictString;
}

// Assignment and constructor operators with char*
DS::DictString(const char* s) {
  m_iterator = findIterator(string(s));
  m_index = m_iterator->second;
}
DS& DS::operator= (const char* s) {
  m_iterator = findIterator(string(s));
  m_index = m_iterator->second;
}

// Assignment and constructor operators with std::string
DS::DictString(const std::string& s) {
  m_iterator = findIterator(s);
  m_index = m_iterator->second;
}
DS& DS::operator=(const std::string& s) {
  m_iterator = findIterator(s);
  m_index = m_iterator->second;
}

bool operator==(const DictString& lhs, const DictString& rhs) {
  return lhs.m_index == rhs.m_index;
}

bool operator!=(const DictString& lhs, const DictString& rhs) {
  return lhs.m_index != rhs.m_index;
}

bool operator<(const DictString& lhs, const DictString& rhs) {
  return lhs.m_index < rhs.m_index;
}

bool operator<= (const DictString& lhs, const DictString& rhs) {
  return lhs.m_index <= rhs.m_index;
}

bool operator> (const DictString& lhs, const DictString& rhs) {
  return lhs.m_index > rhs.m_index;
}

bool operator>= (const DictString& lhs, const DictString& rhs) {
  return lhs.m_index >= rhs.m_index;
}

DictString operator+ (const DictString& lhs, const DictString& rhs) {
  return DictString(lhs.str()+rhs.str());
}

DictString operator+ (const DictString& lhs, const DS::string& rhs) {
  return DictString(lhs.str()+rhs);
}

DictString operator+ (const DictString& lhs, const char*   rhs) {
  return DictString(lhs.str()+rhs);
}

DictString operator+ (const DictString& lhs, const char    rhs) {
  return DictString(lhs.str()+rhs);
}

DictString operator+ (const DS::string&     lhs, const DictString& rhs) {
  return DictString(lhs+rhs.str());
}

DictString operator+ (const char*       lhs, const DictString& rhs) {
  return DictString(lhs+rhs.str());
}

DictString operator+ (char              lhs, const DictString& rhs) {
  std::string lhs_string;
  lhs_string = lhs;
  return DictString(lhs_string+rhs.str());
}

std::ostream& operator<< (std::ostream& os, const DictString& ds) {
  os << ds.str();
}

std::istream& operator>> (std::istream& is, DictString& ds) {
  DS::string temp;
  is >> temp;
  ds = temp;
}

DictString DictString::substr (size_t pos, size_t len) const {
  return DictString(str().substr(pos, len));
}