RangeState.h

Go to the documentation of this file.

/* -*- c++ -*-
 * Copyright (C) 2007-2015 Hypertable, Inc.
 *
 * This file is part of Hypertable.
 *
 * Hypertable is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; version 3 of the
 * License, or any later version.
 *
 * Hypertable is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */

#ifndef Hypertable_Lib_RangeState_h
#define Hypertable_Lib_RangeState_h

#include <Common/PageArenaAllocator.h>
#include <Common/String.h>
#include <Common/Serializable.h>

namespace Hypertable {


  class RangeState : public Serializable {
  public:

    enum StateType {
      STEADY,                   
      SPLIT_LOG_INSTALLED,      
      SPLIT_SHRUNK,             
      RELINQUISH_LOG_INSTALLED, 
      RELINQUISH_COMPACTED,     
      PHANTOM =  0x80           
    };

    RangeState() : state(STEADY), timestamp(0), soft_limit(0), transfer_log(0),
                   split_point(0), old_boundary_row(0), source(0) { }

    RangeState(CharArena &arena, const RangeState &other) {
      state = other.state;
      timestamp = other.timestamp;
      soft_limit = other.soft_limit;
      transfer_log = other.transfer_log ? arena.dup(other.transfer_log) : 0;
      split_point = other.split_point ? arena.dup(other.split_point) : 0;
      old_boundary_row = other.old_boundary_row ? arena.dup(other.old_boundary_row) : 0;
      source = other.source ? arena.dup(other.source) : 0;
    }

    virtual ~RangeState() {}

    virtual void clear();

    static std::string get_text(uint8_t state);

    uint8_t state;

    int64_t timestamp;

    uint64_t soft_limit;

    const char *transfer_log;

    const char *split_point;

    const char *old_boundary_row;

    const char *source;

  protected:

    uint8_t encoding_version() const override;


    size_t encoded_length_internal() const override;

    void encode_internal(uint8_t **bufp) const override;

    void decode_internal(uint8_t version, const uint8_t **bufp,
                         size_t *remainp) override;

  };

  std::ostream &operator<<(std::ostream &out, const RangeState &st);

  class RangeStateManaged : public RangeState {
  public:

    RangeStateManaged() { }

    RangeStateManaged(const RangeStateManaged &rs) {
      operator=(rs);
    }

    RangeStateManaged(const RangeState &rs) {
      operator=(rs);
    }

    virtual ~RangeStateManaged() {}

    void clear() override;

    RangeStateManaged& operator=(const RangeStateManaged &other) {
      const RangeState *otherp = &other;
      return operator=(*otherp);
    }

    RangeStateManaged& operator=(const RangeState &rs) {
      state = rs.state;
      timestamp = rs.timestamp;
      soft_limit = rs.soft_limit;

      if (rs.transfer_log) {
        m_transfer_log = rs.transfer_log;
        transfer_log = m_transfer_log.c_str();
      }
      else
        clear_transfer_log();

      if (rs.split_point) {
        m_split_point = rs.split_point;
        split_point = m_split_point.c_str();
      }
      else
        clear_split_point();

      if (rs.old_boundary_row) {
        m_old_boundary_row = rs.old_boundary_row;
        old_boundary_row = m_old_boundary_row.c_str();
      }
      else
        clear_old_boundary_row();

      if (rs.source) {
        m_source = rs.source;
        source = m_source.c_str();
      }
      else
        clear_source();

      return *this;
    }

    void set_transfer_log(const std::string &tl) {
      m_transfer_log = tl;
      transfer_log = m_transfer_log.c_str();
    }

    void clear_transfer_log() {
      m_transfer_log = "";
      transfer_log = 0;
    }

    void set_split_point(const std::string &sp) {
      m_split_point = sp;
      split_point = m_split_point.c_str();
    }

    void clear_split_point() {
      m_split_point = "";
      split_point = 0;
    }

    void set_old_boundary_row(const std::string &obr) {
      m_old_boundary_row = obr;
      old_boundary_row = m_old_boundary_row.c_str();
    }

    void clear_old_boundary_row() {
      m_old_boundary_row = "";
      old_boundary_row = 0;
    }

    void set_source(const std::string &src) {
      m_source = src;
      source = m_source.c_str();
    }

    void clear_source() {
      m_source = "";
      source = 0;
    }

  private:

    void decode_internal(uint8_t version, const uint8_t **bufp,
                         size_t *remainp) override;

    std::string m_transfer_log;

    std::string m_split_point;

    std::string m_old_boundary_row;

    std::string m_source;
  };


}

#endif // Hypertable_Lib_RangeState_h