html_element.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_HTML_HTML_ELEMENT_H_
#define PAGESPEED_KERNEL_HTML_HTML_ELEMENT_H_

#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/inline_slist.h"
#include "pagespeed/kernel/base/scoped_ptr.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/html/html_name.h"
#include "pagespeed/kernel/html/html_node.h"

namespace net_instaweb {

class HtmlElement : public HtmlNode {
 public:
  enum Style {
    AUTO_CLOSE,      
    IMPLICIT_CLOSE,  
    EXPLICIT_CLOSE,  
    BRIEF_CLOSE,     
    UNCLOSED,        
    INVISIBLE,       
  };

  enum QuoteStyle {
    NO_QUOTE,
    SINGLE_QUOTE,
    DOUBLE_QUOTE
  };

  class Attribute : public InlineSListElement<Attribute> {
   public:


    StringPiece name_str() const { return name_.value(); }

    HtmlName::Keyword keyword() const { return name_.keyword(); }

    HtmlName name() const { return name_; }
    void set_name(const HtmlName& name) { name_ = name; }

    const char* escaped_value() const { return escaped_value_.get(); }

    const char* DecodedValueOrNull() const {
      if (!decoded_value_computed_) {
        ComputeDecodedValue();
      }
      return decoded_value_.get();
    }

    void set_decoding_error(bool x) { decoding_error_ = x; }
    bool decoding_error() const {
      if (!decoded_value_computed_) {
        ComputeDecodedValue();
      }
      return decoding_error_;
    }

    QuoteStyle quote_style() const { return quote_style_; }

    const char* quote_str() const;


    void SetValue(const StringPiece& value);

    void SetEscapedValue(const StringPiece& value);

    void set_quote_style(QuoteStyle new_quote_style) {
      quote_style_ = new_quote_style;
    }

    friend class HtmlElement;

   private:
    void ComputeDecodedValue() const;

    Attribute(const HtmlName& name, const StringPiece& escaped_value,
              QuoteStyle quote_style);

    static inline void CopyValue(const StringPiece& src,
                                 scoped_array<char>* dst);

    HtmlName name_;
    QuoteStyle quote_style_ : 8;
    mutable bool decoding_error_;
    mutable bool decoded_value_computed_;

    scoped_array<char> escaped_value_;

    mutable scoped_array<char> decoded_value_;

    
  };

  typedef InlineSList<Attribute> AttributeList;
  typedef InlineSList<Attribute>::Iterator AttributeIterator;
  typedef InlineSList<Attribute>::ConstIterator AttributeConstIterator;

  virtual ~HtmlElement();

  virtual bool live() const { return (data_.get() != NULL) && data_->live_; }

  virtual void MarkAsDead(const HtmlEventListIterator& end);

  void AddAttribute(const Attribute& attr);

  void AddAttribute(const HtmlName& name,
                    const StringPiece& decoded_value,
                    QuoteStyle quote_style);
  void AddEscapedAttribute(const HtmlName& name,
                           const StringPiece& escaped_value,
                           QuoteStyle quote_style);

  bool DeleteAttribute(HtmlName::Keyword keyword);
  bool DeleteAttribute(StringPiece name);

  const Attribute* FindAttribute(HtmlName::Keyword keyword) const;
  Attribute* FindAttribute(HtmlName::Keyword keyword) {
    const HtmlElement* const_this = this;
    const Attribute* result = const_this->FindAttribute(keyword);
    return const_cast<Attribute*>(result);
  }

  const Attribute* FindAttribute(StringPiece name) const;
  Attribute* FindAttribute(StringPiece name) {
    const HtmlElement* const_this = this;
    const Attribute* result = const_this->FindAttribute(name);
    return const_cast<Attribute*>(result);
  }

  bool HasAttribute(HtmlName::Keyword keyword) const {
    const Attribute* attribute = FindAttribute(keyword);
    return attribute != nullptr;
  }

  const char* AttributeValue(HtmlName::Keyword name) const {
    const Attribute* attribute = FindAttribute(name);
    if (attribute != NULL) {
      return attribute->DecodedValueOrNull();
    }
    return NULL;
  }

  const char* EscapedAttributeValue(HtmlName::Keyword name) const {
    const Attribute* attribute = FindAttribute(name);
    if (attribute != NULL) {
      return attribute->escaped_value();
    }
    return NULL;
  }

  StringPiece name_str() const { return data_->name_.value(); }

  HtmlName::Keyword keyword() const { return data_->name_.keyword(); }

  const HtmlName& name() const { return data_->name_; }

  void set_name(const HtmlName& new_tag) { data_->name_ = new_tag; }

  const AttributeList& attributes() const { return data_->attributes_; }
  AttributeList* mutable_attributes() { return &data_->attributes_; }

  friend class HtmlParse;
  friend class HtmlLexer;

  Style style() const { return data_->style_; }
  void set_style(Style style) { data_->style_ = style; }

  virtual GoogleString ToString() const;
  void DebugPrint() const;

  int begin_line_number() const { return data_->begin_line_number_; }
  int end_line_number() const { return data_->end_line_number_; }

 protected:
  virtual void SynthesizeEvents(const HtmlEventListIterator& iter,
                                HtmlEventList* queue);

  virtual HtmlEventListIterator begin() const { return data_->begin_; }
  virtual HtmlEventListIterator end() const { return data_->end_; }

 private:
  struct Data {
    Data(const HtmlName& name,
         const HtmlEventListIterator& begin,
         const HtmlEventListIterator& end);
    ~Data();

    static const unsigned kMaxLineNumber = 0x00ffffff;

    unsigned begin_line_number_ : 24;
    unsigned live_ : 8;
    unsigned end_line_number_ : 24;
    Style style_ : 8;

    HtmlName name_;
    AttributeList attributes_;
    HtmlEventListIterator begin_;
    HtmlEventListIterator end_;
  };

  void set_begin(const HtmlEventListIterator& begin) { data_->begin_ = begin; }
  void set_end(const HtmlEventListIterator& end) { data_->end_ = end; }

  void set_begin_line_number(int line) { data_->begin_line_number_ = line; }
  void set_end_line_number(int line) { data_->end_line_number_ = line; }

  HtmlElement(HtmlElement* parent, const HtmlName& name,
              const HtmlEventListIterator& begin,
              const HtmlEventListIterator& end);

  void FreeData() { data_.reset(NULL); }

  scoped_ptr<Data> data_;

  
};

}  

#endif