shared_string.h

Go to the documentation of this file.

/*
 * Copyright 2010 Google Inc.
 *
 * 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.
 */


#ifndef PAGESPEED_KERNEL_BASE_SHARED_STRING_H_
#define PAGESPEED_KERNEL_BASE_SHARED_STRING_H_

#include <cstddef>                     

#include "base/logging.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/base/ref_counted_ptr.h"

namespace net_instaweb {

class SharedString {
 public:
  SharedString();

  explicit SharedString(const StringPiece& str);

  explicit SharedString(const GoogleString& str);

  explicit SharedString(const char* str);

  SharedString(const SharedString& src);
  SharedString& operator=(const SharedString& src);

  StringPiece Value() const;

  void Assign(StringPiece str) { Assign(str.data(), str.size()); }
  void Assign(const char* data, int size);

  void Append(StringPiece str) { Append(str.data(), str.size()); }
  void Append(const char* data, size_t size);

  void Extend(int new_size);

  void SwapWithString(GoogleString* str);

  void DetachAndClear();

  void RemovePrefix(int n);

  void RemoveSuffix(int n);

  int size() const { return size_; }
  bool empty() const { return size_ == 0; }
  const char* data() const { return ref_string_->data() + skip_; }

  void WriteAt(int dest_offset, const char* source, int count);

  void DetachRetainingContent() {
    if (!unique()) {
      *this = SharedString(Value());
      DCHECK(unique());
    }
  }

  bool unique() const { return ref_string_.unique(); }

  bool trimmed() const {
    return size_ != static_cast<int>(ref_string_->size());
  }

  const GoogleString* StringValue() const {
    return ref_string_.get();
  }

  bool SharesStorage(const SharedString& that) const {
    return ref_string_.get() == that.ref_string_.get();
  }

 private:
  void UniquifyIfTruncated();
  char* mutable_data() { return &(*ref_string_.get())[0] + skip_; }
  void ClearIfShared() {
    if (!unique()) {
      DetachAndClear();
    }
  }

  RefCountedObj<GoogleString> ref_string_;

  int skip_; 
  int size_; 
};

}  

#endif