docs: function(feature) {
          var attrib = feature.attributes;
          var atomAttrib = attrib.atom || {};
          var entryNode = this.createElementNSPlus("atom:entry");
          
          // atom:author
          if (atomAttrib.authors) {
              var authors = OpenLayers.Util.isArray(atomAttrib.authors) ?
                  atomAttrib.authors : [atomAttrib.authors];
              for (var i=0, ii=authors.length; i<ii; i++) {
                  entryNode.appendChild(
                      this.buildPersonConstructNode(
                          "author", authors[i]
                      )
                  );
              }
          }
          
          // atom:category
          if (atomAttrib.categories) {
              var categories = OpenLayers.Util.isArray(atomAttrib.categories) ?
                  atomAttrib.categories : [atomAttrib.categories];
              var category;
              for (var i=0, ii=categories.length; i<ii; i++) {
                  category = categories[i];
                  entryNode.appendChild(
                      this.createElementNSPlus("atom:category", {
                          attributes: {
                              term: category.term,
                              scheme: category.scheme || null,
                              label: category.label || null
                          }
                      })
                  );
              }
          }
          
          // atom:content
          if (atomAttrib.content) {
              entryNode.appendChild(this.buildContentNode(atomAttrib.content));
          }
          
          // atom:contributor
          if (atomAttrib.contributors) {
              var contributors = OpenLayers.Util.isArray(atomAttrib.contributors) ?
                  atomAttrib.contributors : [atomAttrib.contributors];
              for (var i=0, ii=contributors.length; i<ii; i++) {
                  entryNode.appendChild(
                      this.buildPersonConstructNode(
                          "contributor",
                          contributors[i]
                          )
                      );
              }
          }
          
          // atom:id
          if (feature.fid) {
              entryNode.appendChild(
                  this.createElementNSPlus("atom:id", {
                      value: feature.fid
                  })
              );
          }
          
          // atom:link
          if (atomAttrib.links) {
              var links = OpenLayers.Util.isArray(atomAttrib.links) ?
                  atomAttrib.links : [atomAttrib.links];
              var link;
              for (var i=0, ii=links.length; i<ii; i++) {
                  link = links[i];
                  entryNode.appendChild(
                      this.createElementNSPlus("atom:link", {
                          attributes: {
                              href: link.href,
                              rel: link.rel || null,
                              type: link.type || null,
                              hreflang: link.hreflang || null,
                              title: link.title || null,
                              length: link.length || null
                          }
                      })
                  );
              }
          }
          
          // atom:published
          if (atomAttrib.published) {
              entryNode.appendChild(
                  this.createElementNSPlus("atom:published", {
                      value: atomAttrib.published
                  })
              );
          }
          
          // atom:rights
          if (atomAttrib.rights) {
              entryNode.appendChild(
                  this.createElementNSPlus("atom:rights", {
                      value: atomAttrib.rights
                  })
              );
          }
          
          // atom:source not implemented
          
          // atom:summary
          if (atomAttrib.summary || attrib.description) {
              entryNode.appendChild(
                  this.createElementNSPlus("atom:summary", {
                      value: atomAttrib.summary || attrib.description
                  })
              );
          }
          
          // atom:title
          entryNode.appendChild(
              this.createElementNSPlus("atom:title", {
                  value: atomAttrib.title || attrib.title || this.defaultEntryTitle
              })
          );
          
          // atom:updated
          if (atomAttrib.updated) {
              entryNode.appendChild(
                  this.createElementNSPlus("atom:updated", {
                      value: atomAttrib.updated
                  })
              );
          }
          
          // georss:where
          if (feature.geometry) {
              var whereNode = this.createElementNSPlus("georss:where");
              whereNode.appendChild(
                  this.buildGeometryNode(feature.geometry)
              );
              entryNode.appendChild(whereNode);
          }
          
          return entryNode;
      }