initial commit

lib/wType/address.cpp

@@ -0,0 +1,326 @@
+#include "address.h"
+
+W::Address::Address():
+    Object(),
+    data(new List())
+{
+
+}
+
+W::Address::Address(const W::Address::InitList& list):
+    Object(),
+    data(new List())
+{
+    InitList::const_iterator itr = list.begin();
+    InitList::const_iterator end = list.end();
+    
+    for (; itr != end; ++itr)
+    {
+        data->emplace_back(String(*itr));
+    }
+}
+
+W::Address::Address(const W::Address& original):
+    Object(),
+    data(new List(*original.data))
+{
+
+}
+
+W::Address::~Address()
+{
+    delete data;
+}
+
+W::Address& W::Address::operator=(const W::Address& original)
+{
+    if (&original != this) 
+    {
+        data->clear();
+        data->insert(data->end(), original.data->begin(), original.data->end());
+    }
+    return *this;
+}
+
+W::Object::size_type W::Address::length() const
+{
+    return data->size();
+}
+
+W::Object::objectType W::Address::getType() const
+{
+    return type;
+}
+
+W::Object::StdStr W::Address::toString() const
+{
+    StdStr str;
+    
+    List::const_iterator itr;
+    List::const_iterator beg = data->begin();
+    List::const_iterator end = data->end();
+    
+    str += '[';
+    for (itr = beg; itr != end; ++itr)
+    {
+        if (itr != beg)
+        {
+            str += ", ";
+        }
+        str += itr->toString();
+    }
+    str += ']';
+    
+    return str;
+}
+
+W::Object* W::Address::copy() const
+{
+    return new Address(*this);
+}
+
+void W::Address::serialize(W::ByteArray& out) const
+{
+    out.push32(length());
+    
+    List::const_iterator itr;
+    List::const_iterator beg = data->begin();
+    List::const_iterator end = data->end();
+    
+    for (itr = beg; itr != end; ++itr)
+    {
+        itr->serialize(out);
+    }
+}
+
+void W::Address::deserialize(W::ByteArray& in)
+{
+    data->clear();
+    
+    size_type length = in.pop32();
+    
+    for (size_type i = 0; i != length; ++i)
+    {
+        data->emplace_back(String());
+        data->back().deserialize(in);
+    }
+}
+
+bool W::Address::operator<(const W::Address& other) const
+{
+    return *data < *other.data;
+}
+
+bool W::Address::operator>(const W::Address& other) const
+{
+    return *data > *other.data;
+}
+
+bool W::Address::operator==(const W::Address& other) const
+{
+    return *data == *other.data;
+}
+
+bool W::Address::operator!=(const W::Address& other) const
+{
+    return *data != *other.data;
+}
+
+bool W::Address::operator<=(const W::Address& other) const
+{
+    return *data <= *other.data;
+}
+
+bool W::Address::operator>=(const W::Address& other) const
+{
+    return *data >= *other.data;
+}
+
+bool W::Address::begins(const W::Address& other) const
+{
+    if (other.length() > length())
+    {
+        return false;
+    }
+    
+    List::const_iterator itr_o = other.data->begin();
+    List::const_iterator end_o = other.data->end();
+    
+    List::const_iterator itr_i = data->begin();
+    
+    while (itr_o != end_o)
+    {
+        if (*itr_o != *itr_i) {
+            return false;
+        }
+        
+        ++itr_o;
+        ++itr_i;
+    }
+    
+    return true;
+}
+
+bool W::Address::ends(const W::Address& other) const
+{
+    if (other.length() > length())
+    {
+        return false;
+    }
+    
+    List::const_reverse_iterator itr_o = other.data->rbegin();
+    List::const_reverse_iterator end_o = other.data->rend();
+    
+    List::const_reverse_iterator itr_i = data->rbegin();
+    
+    while (itr_o != end_o)
+    {
+        if (*itr_o != *itr_i) {
+            return false;
+        }
+        
+        ++itr_o;
+        ++itr_i;
+    }
+    
+    return true;
+}
+
+bool W::Address::contains(const W::Address& other, int position) const
+{
+    if (other.length() > length() - position)
+    {
+        return false;
+    }
+    
+    bool res = true;
+    
+    List::const_iterator itr_o = other.data->begin();
+    List::const_iterator end_o = other.data->end();
+    
+    List::const_iterator itr_i = data->begin();
+    
+    for (int i = 0; i < position; ++i) {
+        ++itr_i;
+    }
+    
+    while (res == true && itr_o != end_o)
+    {
+        res = *itr_o == *itr_i;
+        
+        ++itr_o;
+        ++itr_i;
+    }
+    
+    return res;
+}
+
+W::Address& W::Address::operator+=(const W::Address& other)
+{
+    data->insert(data->end(), other.data->begin(), other.data->end());
+    return *this;
+}
+
+W::Address& W::Address::operator+=(const W::String& other)
+{
+    data->push_back(other);
+    return *this;
+}
+
+W::Address& W::Address::operator+=(const W::String::u16string& other)
+{
+    String hop(other);
+    return operator+=(hop);
+}
+
+W::Address W::Address::operator>>(W::Object::size_type count) const
+{
+    W::Address res;
+    if (count < length())
+    { 
+        List::const_iterator itr = data->end();
+        for (size_type i = 0; i != count; ++i)
+        {
+            itr--;
+        }
+        List::const_iterator beg = data->begin();
+        res.data->insert(res.data->end(), beg, itr);
+    }
+    return res;
+}
+
+W::Address W::Address::operator<<(W::Object::size_type count) const
+{
+    W::Address res;
+    if (count < length())
+    { 
+        List::const_iterator itr = data->begin();
+        for (size_type i = 0; i != count; ++i)
+        {
+            itr++;
+        }
+        List::const_iterator end = data->end();
+        res.data->insert(res.data->end(), itr, end);
+    }
+    return res;
+}
+
+W::Address W::Address::operator+(const W::Address& other) const
+{
+    W::Address res;
+    res += *this;
+    res += other;
+    
+    return res;
+}
+
+W::Address & W::Address::operator+=(const Uint64& other)
+{
+    data->push_back(String(other.toString()));
+    
+    return *this;
+}
+
+
+W::Address W::Address::operator+(const Uint64& other) const
+{
+    W::Address res;
+    res += *this;
+    res += other;
+    
+    return res;
+}
+
+
+const W::String& W::Address::front() const
+{
+    return data->front();
+}
+
+const W::String& W::Address::back() const
+{
+    return data->back();
+}
+
+bool W::Address::operator==(const W::Object& other) const
+{
+    if (sameType(other)) {
+        return operator==(static_cast<const W::Address&>(other));
+    } else {
+        return false;
+    }
+}
+
+W::Object::size_type W::Address::size() const
+{
+    size_type size = 4;
+    List::const_iterator itr = data->begin();
+    List::const_iterator end = data->end();
+    
+    for (; itr != end; ++itr)
+    {
+        size += itr->size();
+    }
+    
+    return size;
+}