Segments.hpp

/*
 * Open Chinese Convert
 *
 * Copyright 2010-2014 Carbo Kuo <byvoid@byvoid.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include <cstring>
#include <iterator>
 
#include "Common.hpp"
 
namespace opencc {
class OPENCC_EXPORT Segments {
public:
  Segments() {}
 
  Segments(std::initializer_list<const char*> initList) {
    for (const char* item : initList) {
      AddSegment(item);
    }
  }
 
  Segments(std::initializer_list<std::string> initList) {
    for (const std::string& item : initList) {
      AddSegment(item);
    }
  }
 
  void AddSegment(const char* unmanagedString) {
    indexes.push_back(std::make_pair(unmanaged.size(), false));
    unmanaged.push_back(unmanagedString);
  }
 
  void AddSegment(const std::string& str) {
    indexes.push_back(std::make_pair(managed.size(), true));
    managed.push_back(str);
  }
 
  class iterator {
  public:
    using iterator_category = std::input_iterator_tag;
    using value_type = const char*;
 
    iterator(const Segments* const _segments, size_t _cursor)
        : segments(_segments), cursor(_cursor) {}
 
    iterator& operator++() {
      cursor++;
      return *this;
    }
 
    bool operator==(const iterator& that) const {
      return cursor == that.cursor && segments == that.segments;
    }
 
    bool operator!=(const iterator& that) const {
      return !this->operator==(that);
    }
 
    const char* operator*() const { return segments->At(cursor); }
 
  private:
    const Segments* const segments;
    size_t cursor;
  };
 
  const char* At(size_t cursor) const {
    const auto& index = indexes[cursor];
    if (index.second) {
      return managed[index.first].c_str();
    } else {
      return unmanaged[index.first];
    }
  }
 
  size_t Length() const { return indexes.size(); }
 
  iterator begin() const { return iterator(this, 0); }
 
  iterator end() const { return iterator(this, indexes.size()); }
 
  std::string ToString() const {
    size_t totalLength = 0;
    for (const char* segment : *this) {
      totalLength += std::strlen(segment);
    }
 
    std::string buffer;
    buffer.reserve(totalLength);
    for (const char* segment : *this) {
      buffer.append(segment);
    }
    return buffer;
  }
 
  std::vector<std::string> ToVector() const {
    std::vector<std::string> result;
    result.reserve(indexes.size());
    for (const char* segment : *this) {
      result.emplace_back(segment);
    }
    return result;
  }
 
private:
  Segments(const Segments&) {}
 
  std::vector<const char*> unmanaged;
  std::vector<std::string> managed;
  // index, managed
  std::vector<std::pair<size_t, bool>> indexes;
};
} // namespace opencc