tuple.nc

用于传感器网络的节点操作系统 TinyOS 结构设计非常有意思

/*									tab:4
 *
 *
 * "Copyright (c) 2000-2002 The Regents of the University  of California.  
 * All rights reserved.
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose, without fee, and without written agreement is
 * hereby granted, provided that the above copyright notice, the following
 * two paragraphs and the author appear in all copies of this software.
 * 
 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
 * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * 
 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS."
 *
 */
/*									tab:4
 *  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.  By
 *  downloading, copying, installing or using the software you agree to
 *  this license.  If you do not agree to this license, do not download,
 *  install, copy or use the software.
 *
 *  Intel Open Source License 
 *
 *  Copyright (c) 2002 Intel Corporation 
 *  All rights reserved. 
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are
 *  met:
 * 
 *	Redistributions of source code must retain the above copyright
 *  notice, this list of conditions and the following disclaimer.
 *	Redistributions in binary form must reproduce the above copyright
 *  notice, this list of conditions and the following disclaimer in the
 *  documentation and/or other materials provided with the distribution.
 *      Neither the name of the Intel Corporation nor the names of its
 *  contributors may be used to endorse or promote products derived from
 *  this software without specific prior written permission.
 *  
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 *  PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE INTEL OR ITS
 *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 *  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * 
 * 
 */
/*
 * Authors:	Sam Madden
 *              Design by Sam Madden, Wei Hong, and Joe Hellerstein
 * Date last modified:  6/26/02
 *
 *
 */

includes SchemaType;

/* Routines to manage a tuple */
module Tuple {
  provides {
    interface TupleIntf;
  }
  uses {
    interface AttrUse;
    interface ParsedQueryIntf;
    interface QueryProcessor;
  }
}

implementation {
  uint16_t typeToSize(TOSType type);

  //return the size of a tuple for a given query
  command uint16_t TupleIntf.tupleSize(ParsedQueryPtr q) {
    short i;
    short size = sizeof(Tuple);

    for (i = 0 ; i < q->numFields; i++) {
      size += call TupleIntf.fieldSize(q, (uint8_t)i);
      
    }
    return size;
    
  }
  
  //return the size of a field for a given query
  command uint16_t TupleIntf.fieldSize(ParsedQueryPtr q, uint8_t fieldNo) {
    if (q->fromQid != kNO_QUERY) {
      ParsedQuery *fromq = call QueryProcessor.getQueryCmd(q->fromQid);
      uint8_t from_fieldNo = q->queryToSchemaFieldMap[(short)fieldNo];

      if (fromq == NULL) return 0;
      
      if (!call ParsedQueryIntf.queryFieldIsNull(fromq->queryToSchemaFieldMap[(short)from_fieldNo])) {
	if (fromq->queryToSchemaFieldMap[(short)from_fieldNo] == GROUP_FIELD)
	  return typeToSize(UINT16); //group is 16bits
	else {
	  AttrDescPtr attr = call AttrUse.getAttrById(fromq->queryToSchemaFieldMap[(short)from_fieldNo]);
	  return typeToSize(attr->type);
	}
	  
      } else
	return 0;
    } else {
      if (!call ParsedQueryIntf.queryFieldIsNull(q->queryToSchemaFieldMap[(short)fieldNo])) {
	AttrDescPtr attr = call AttrUse.getAttrById(q->queryToSchemaFieldMap[(short)fieldNo]);
	return typeToSize(attr->type);
      } else
	return 0;
    }
  }

  /* Set the value of a specified field to data */
  command result_t TupleIntf.setField(ParsedQueryPtr q, TuplePtr t, uint8_t fieldIdx, CharPtr data) {
    char *dest = call TupleIntf.getFieldPtr(q, t, fieldIdx);
    if (dest != data)
      memcpy(dest, data, call TupleIntf.fieldSize(q, fieldIdx));
    t->notNull |= (1 << fieldIdx);
    return SUCCESS;
  }


  /* Get the value of the specified field in the specified tuple
     of the specified query
     fieldIdx begins at 0
  */

  command CharPtr TupleIntf.getFieldPtr(ParsedQueryPtr q, TuplePtr t, uint8_t fieldIdx){
    short i;
    short offset = 0;

    //if ((t->notNull & (1 << fieldIdx)) == 0 ) return NULL;    
    for (i = 0; i < fieldIdx; i++) {
      offset += call TupleIntf.fieldSize(q, i);
    }
    return (char *)(&t->fields[offset]);    
  }

  
  //reset the specified tuple to be empty
  command result_t TupleIntf.tupleInit(ParsedQueryPtr q, TuplePtr t){
    t->notNull = 0; //all fields null
    t->qid = q->qid;
    t->numFields = q->numFields;
    
    return SUCCESS;
    
  }

  //return true iff the query is complete (e.g. all fields that are not supposed to be null are non-null)
  command bool TupleIntf.isTupleComplete(ParsedQueryPtr q, TuplePtr t){
    short i;
    
    for (i = 0; i < q->numFields; i++) {
      if (!call ParsedQueryIntf.queryFieldIsNull(q->queryToSchemaFieldMap[i])) { //if field is not supposed to be null
	if ((t->notNull & (1 << i)) == 0) return FALSE; //but it is, return false
      }
    }
    return TRUE;  //all fields that are not supposed to be null are non-null
  }

  //scan the tuple, looking for null fields that shouldn't be null
  //(e.g. fields that need to be filled in)
  //return the attr desc of the first one
  command AttrDescPtr TupleIntf.getNextQueryField(ParsedQueryPtr q, TuplePtr t){
    uint8_t i;
    TinyDBError err;

    err = call TupleIntf.getNextEmptyFieldIdx(q,t,&i);
    if (err == err_NoError) {
	return call AttrUse.getAttrById(q->queryToSchemaFieldMap[i]);
    } else
	return NULL;
  }

  //scan the tuple, looking for null fields that shouldn't be null
  //(e.g. fields that need to be filled in)
  //return the index of the first one
  command TinyDBError TupleIntf.getNextEmptyFieldIdx(ParsedQueryPtr q, TuplePtr t, uint8_t *fieldIdx) {
      short i;

      for (i = 0; i < q->numFields; i++) {
	  if (!call ParsedQueryIntf.queryFieldIsNull(q->queryToSchemaFieldMap[i]) && //shouldn't be null
	      (t->notNull & (1 << i)) == 0 ) { //but is
	      *fieldIdx = i;
	      return err_NoError;
	  }
      }
      return err_NoMoreResults;
  }


  uint16_t typeToSize(TOSType type) {
    return sizeOf(type);
  }

  event result_t AttrUse.getAttrDone(char *name, char *resultBuf, SchemaErrorNo errorNo) {
    return SUCCESS;
  }

  event result_t QueryProcessor.queryComplete(ParsedQueryPtr q) {
    return SUCCESS;
  }

}