Replies the size of the DBase field which must contains the
value of the given attribute value.

@return the size of the field in bytes
@throws DBaseFileException if the Dbase file cannot be read.
@throws AttributeException  if an attribute is invalid.
344875
private static int computeFieldSize(AttributeValue value) throws DBaseFileException, AttributeException {
		final DBaseFieldType dbftype = DBaseFieldType.fromAttributeType(value.getType());
		return dbftype.getFieldSize(value.getString());
	}
669337
def size(self):
        ''''''
        c = self.database.cursor()
        r = c.execute("SELECT sum(size) FROM files")

        try:
            size = int(r.fetchone()[0])
        except TypeError:
            size = 0

        return size
751943
int getSize() {
        int size = 0;
        AnnotationWriter aw = this;
        while (aw != null) {
            size += aw.bv.length;
            aw = aw.next;
        }
        return size;
    }
767089
@Override
	public int size() {
		Long longSize = 0L;
		try {
			longSize = new Long(redisManager.dbSize(keySerializer.serialize(this.keyPrefix + "*")));
		} catch (SerializationException e) {
			logger.error("get keys error", e);
		}
		return longSize.intValue();
	}
581800
protected int getSize()
   {
      if (tc.isEntryEnabled()) SibTr.entry(this, tc, "getSize");
      int headerSize = 0;
      if (layout == JFapChannelConstants.XMIT_PRIMARY_ONLY)
         headerSize = JFapChannelConstants.SIZEOF_PRIMARY_HEADER;
      else if (layout == JFapChannelConstants.XMIT_CONVERSATION)
         headerSize = JFapChannelConstants.SIZEOF_PRIMARY_HEADER + JFapChannelConstants.SIZEOF_CONVERSATION_HEADER;
      else if (layout == JFapChannelConstants.XMIT_SEGMENT_START)
         headerSize = JFapChannelConstants.SIZEOF_PRIMARY_HEADER + JFapChannelConstants.SIZEOF_CONVERSATION_HEADER + JFapChannelConstants.SIZEOF_SEGMENT_START_HEADER;
      else if (layout == JFapChannelConstants.XMIT_SEGMENT_MIDDLE)
         headerSize = JFapChannelConstants.SIZEOF_PRIMARY_HEADER + JFapChannelConstants.SIZEOF_CONVERSATION_HEADER;
      else if (layout == JFapChannelConstants.XMIT_SEGMENT_END)
         headerSize = JFapChannelConstants.SIZEOF_PRIMARY_HEADER + JFapChannelConstants.SIZEOF_CONVERSATION_HEADER;
      else
      {
         throw new SIErrorException(TraceNLS.getFormattedMessage(JFapChannelConstants.MSG_BUNDLE, "TRANSDATA_INTERNAL_SICJ0060", null, "TRANSDATA_INTERNAL_SICJ0060")); // D226223 
      }
      int retValue = primaryHeaderFields.segmentLength - headerSize;
      if (tc.isEntryEnabled()) SibTr.exit(this, tc, "getSize", ""+retValue);
      return retValue;
   }
1356519
@View(name = "size", map = "function(doc) { if (doc.service) { emit(doc, doc._id) }}", reduce = "_count")
    public int size() {
        val r = db.queryView(createQuery("size"));
        LOGGER.trace("r.isEmpty [{}]", r.isEmpty());
        LOGGER.trace("r.getRows [{}]", r.getRows());
        if (r.isEmpty()) {
            return 0;
        }

        return r.getRows().get(0).getValueAsInt();
    }
1016428
static public int getByteSize() {
    int size = 0;
    size += 16;
    size += 16;
    size += 24;
    size += 24;
    size += 20;
    size += 3;
    size += 5;
    size += 36;
    size += 64;
    size += 64;
    size = size/8;
    return size;
  }
441800
public int getSerializedSize() {
    int size = 0;
    for (int i = 0; i < fields.getNumArrayEntries(); i++) {
      final Map.Entry<FieldDescriptorType, Object> entry =
          fields.getArrayEntryAt(i);
      size += computeFieldSize(entry.getKey(), entry.getValue());
    }
    for (final Map.Entry<FieldDescriptorType, Object> entry :
         fields.getOverflowEntries()) {
      size += computeFieldSize(entry.getKey(), entry.getValue());
    }
    return size;
  }
481432
@Override
    public int size ()
    {
        // dumb implementation. You should override.
        int size = 0;
        for (Interator it = interator(); (size < Integer.MAX_VALUE) && it.hasNext(); it.nextInt()) {
            size++;
        }
        return size;
    }
793380
public int size() {
		int size = cleared ? 0 : snapshot.size();
		for ( Map.Entry<RowKey,AssociationOperation> op : currentState.entrySet() ) {
			switch ( op.getValue().getType() ) {
				case PUT:
					if ( cleared || !snapshot.containsKey( op.getKey() ) ) {
						size++;
					}
					break;
				case REMOVE:
					if ( !cleared && snapshot.containsKey( op.getKey() ) ) {
						size--;
					}
					break;
			}
		}
		return size;
	}
456056
@Override
    public long size() throws RepositoryException{
        try {
            MarkLogicTupleQuery tupleQuery = prepareTupleQuery(COUNT_EVERYTHING);
            tupleQuery.setIncludeInferred(false);
            tupleQuery.setRulesets((SPARQLRuleset)null);
            tupleQuery.setConstrainingQueryDefinition((QueryDefinition)null);
            TupleQueryResult qRes = tupleQuery.evaluate();
            // just one answer
            BindingSet result = qRes.next();
            qRes.close();
            return ((Literal) result.getBinding("ct").getValue()).longValue();
        } catch (QueryEvaluationException | MalformedQueryException e) {
            throw new RepositoryException(e);
        }
    }
1192414
@Override
	public int size() {
		lock.readLock().lock();
		try {
			return getKeyMap(false).size();
		} finally {
			lock.readLock().unlock();
		}
	}
485469
public function size()
	{
		if ($this->is_empty())
			return 0;

		$count = 0;

		foreach ($this->errors as $attribute => $error)
			$count += count($error);

		return $count;
	}
1335797
@Override
    public int size () {
        int size = Smb2Constants.SMB2_HEADER_LENGTH + 56;
        int dataLength = 0;
        if ( this.inputData != null ) {
            dataLength += this.inputData.size();
        }
        if ( this.outputData != null ) {
            dataLength += this.outputData.size();
        }
        return size8(size + dataLength);
    }
1319809
public int size()
    {
        class CountProcedure implements Procedure<C>
        {
            private static final long serialVersionUID = 1L;

            private int totalSize;

            public void value(C collection)
            {
                this.totalSize += collection.size();
            }

            public int getTotalSize()
            {
                return this.totalSize;
            }
        }

        CountProcedure procedure = new CountProcedure();
        this.map.forEachValue(procedure);
        return procedure.getTotalSize();
    }
1027804
@Override
	public long getSize() throws IOException {
		if (length < 0) {
			try {
				if (activeMethod != null) {
					length = activeMethod.getResponseContentLength();
				} else {
					acquireLength();
				}
			} catch (URISyntaxException e) {
				throw new IOException(e);
			}
		}
		return length;
	}
1166799
public int size() {
        int count = 0;

        for (int i = 0, size = mScrapLength.size(); i < size; i++) {
            int val = mScrapLength.valueAt(i);
            count += val;
        }

        return count;
    }