typeIDs.cc
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:7k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. #include "typeIDs.hh"
  19. using namespace hadoop;
  20. void TypeID::serialize(::hadoop::OArchive& a_, const char* tag) const
  21. {
  22.   a_.serialize(typeVal, tag);
  23. }
  24. bool TypeID::operator==(const TypeID& peer_) const 
  25. {
  26.   return (this->typeVal == peer_.typeVal);
  27. }
  28. void TypeID::print(int space) const
  29. {
  30.   for (int i=0; i<space; i++) {
  31.     printf(" ");
  32.   }
  33.   printf("typeID(%lx) = %dn", (long)this, typeVal);
  34. }
  35. /*StructTypeID::StructTypeID(const char *p): TypeID(RIOTYPE_STRUCT)
  36. {
  37.   pName = new std::string(p);
  38. }
  39. StructTypeID::StructTypeID(std::string* p): TypeID(RIOTYPE_STRUCT)
  40. {
  41.   this->pName = p;
  42. }*/
  43. StructTypeID::StructTypeID(const std::vector<FieldTypeInfo*>& vec) : 
  44.   TypeID(RIOTYPE_STRUCT) 
  45. {
  46.   // we need to copy object clones into our own vector
  47.   for (unsigned int i=0; i<vec.size(); i++) {
  48.     typeInfos.push_back(vec[i]->clone());
  49.   }
  50. }
  51. /*StructTypeID::StructTypeID(const StructTypeID& ti) :
  52.   TypeID(RIOTYPE_STRUCT)
  53. {
  54.   // we need to copy object clones into our own vector
  55.   for (unsigned int i=0; i<ti.typeInfos.size(); i++) {
  56.     typeInfos.push_back(ti.typeInfos[i]->clone());
  57.   }
  58. } */ 
  59. StructTypeID::~StructTypeID()
  60. {
  61.   for (unsigned int i=0; i<typeInfos.size(); i++) {
  62.     delete typeInfos[i];
  63.   }
  64. }  
  65. void StructTypeID::add(FieldTypeInfo *pti)
  66. {
  67.   typeInfos.push_back(pti);
  68. }
  69. // return the StructTypeiD, if any, of the given field
  70. StructTypeID* StructTypeID::findStruct(const char *pStructName)
  71. {
  72.   // walk through the list, searching. Not the most efficient way, but this
  73.   // in intended to be used rarely, so we keep it simple. 
  74.   // As an optimization, we can keep a hashmap of record name to its RTI, for later.
  75.   for (unsigned int i=0; i<typeInfos.size(); i++) {
  76.     if ((0 == typeInfos[i]->getFieldID()->compare(pStructName)) && 
  77. (typeInfos[i]->getTypeID()->getTypeVal()==RIOTYPE_STRUCT)) {
  78.       return (StructTypeID*)(typeInfos[i]->getTypeID()->clone());
  79.     }
  80.   }
  81.   return NULL;
  82. }
  83. void StructTypeID::serialize(::hadoop::OArchive& a_, const char* tag) const
  84. {
  85.   a_.serialize(typeVal, tag);
  86.   serializeRest(a_, tag);
  87. }
  88. /* 
  89.  * Writes rest of the struct (excluding type value).
  90.  * As an optimization, this method is directly called by RTI 
  91.  * for the top level record so that we don't write out the byte
  92.  * indicating that this is a struct (since top level records are
  93.  * always structs).
  94.  */
  95. void StructTypeID::serializeRest(::hadoop::OArchive& a_, const char* tag) const
  96. {
  97.   a_.serialize((int32_t)typeInfos.size(), tag);
  98.   for (unsigned int i=0; i<typeInfos.size(); i++) {
  99.     typeInfos[i]->serialize(a_, tag);
  100.   }
  101. }
  102. /* 
  103.  * deserialize ourselves. Called by RTI. 
  104.  */
  105. void StructTypeID::deserialize(::hadoop::IArchive& a_, const char* tag)
  106. {
  107.   // number of elements
  108.   int numElems;
  109.   a_.deserialize(numElems, tag);
  110.   for (int i=0; i<numElems; i++) {
  111.     typeInfos.push_back(genericReadTypeInfo(a_, tag));
  112.   }
  113. }
  114. // generic reader: reads the next TypeInfo object from stream and returns it
  115. FieldTypeInfo* StructTypeID::genericReadTypeInfo(::hadoop::IArchive& a_, const char* tag)
  116. {
  117.   // read name of field
  118.   std::string*  pName = new std::string();
  119.   a_.deserialize(*pName, tag);
  120.   TypeID* pti = genericReadTypeID(a_, tag);
  121.   return new FieldTypeInfo(pName, pti);
  122. }
  123. // generic reader: reads the next TypeID object from stream and returns it
  124. TypeID* StructTypeID::genericReadTypeID(::hadoop::IArchive& a_, const char* tag)
  125. {
  126.   int8_t typeVal;
  127.   a_.deserialize(typeVal, tag);
  128.   switch(typeVal) {
  129.   case RIOTYPE_BOOL: 
  130.   case RIOTYPE_BUFFER: 
  131.   case RIOTYPE_BYTE: 
  132.   case RIOTYPE_DOUBLE: 
  133.   case RIOTYPE_FLOAT: 
  134.   case RIOTYPE_INT: 
  135.   case RIOTYPE_LONG: 
  136.   case RIOTYPE_STRING: 
  137.     return new TypeID(typeVal);
  138.   case RIOTYPE_STRUCT: 
  139.     {
  140.       StructTypeID* pstID = new StructTypeID();
  141.       int numElems;
  142.       a_.deserialize(numElems, tag);
  143.       for (int i=0; i<numElems; i++) {
  144. pstID->add(genericReadTypeInfo(a_, tag));
  145.       }
  146.       return pstID;
  147.     }
  148.   case RIOTYPE_VECTOR: 
  149.     {
  150.       TypeID* pti = genericReadTypeID(a_, tag);
  151.       return new VectorTypeID(pti);
  152.     }
  153.   case RIOTYPE_MAP: 
  154.     {
  155.       TypeID* ptiKey = genericReadTypeID(a_, tag);
  156.       TypeID* ptiValue = genericReadTypeID(a_, tag);
  157.       return new MapTypeID(ptiKey, ptiValue);
  158.     }
  159.   default: 
  160.     // shouldn't be here
  161.     return NULL;
  162.   }
  163. }
  164. void StructTypeID::print(int space) const
  165. {
  166.   TypeID::print(space);
  167.   for (int i=0; i<space; i++) {
  168.     printf(" ");
  169.   }
  170.   printf("StructTypeInfo(%lx): n", (long)&typeInfos);
  171.   for (unsigned int i=0; i<typeInfos.size(); i++) {
  172.     typeInfos[i]->print(space+2);
  173.   }
  174. }
  175. VectorTypeID::~VectorTypeID()
  176. {
  177.   delete ptiElement;
  178. }
  179. VectorTypeID::VectorTypeID(const VectorTypeID& ti): TypeID(RIOTYPE_VECTOR)
  180. {
  181.   ptiElement = ti.ptiElement->clone();
  182. }
  183. void VectorTypeID::serialize(::hadoop::OArchive& a_, const char* tag) const
  184. {
  185.   a_.serialize(typeVal, tag);
  186.   ptiElement->serialize(a_, tag);
  187. }
  188. bool VectorTypeID::operator==(const TypeID& peer_) const
  189. {
  190.   if (typeVal != peer_.getTypeVal()) {
  191.     return false;
  192.   }
  193.   // this must be a vector type id
  194.   return (*ptiElement) == (*((VectorTypeID&)peer_).ptiElement);
  195. }
  196. void VectorTypeID::print(int space) const
  197. {
  198.   TypeID::print(space);
  199.   for (int i=0; i<space; i++) {
  200.     printf(" ");
  201.   }
  202.   printf("VectorTypeInfo(%lx): n", (long)this);
  203.   ptiElement->print(space+2);
  204. }
  205. MapTypeID::~MapTypeID()
  206. {
  207.   delete ptiKey;
  208.   delete ptiValue;
  209. }
  210. MapTypeID::MapTypeID(const MapTypeID& ti): TypeID(RIOTYPE_MAP)
  211. {
  212.   ptiKey = ti.ptiKey->clone();
  213.   ptiValue = ti.ptiValue->clone();
  214. }
  215. void MapTypeID::serialize(::hadoop::OArchive& a_, const char* tag) const
  216. {
  217.   a_.serialize(typeVal, tag);
  218.   ptiKey->serialize(a_, tag);
  219.   ptiValue->serialize(a_, tag);
  220. }
  221. bool MapTypeID::operator==(const TypeID& peer_) const
  222. {
  223.   if (typeVal != peer_.getTypeVal()) {
  224.     return false;
  225.   }
  226.   // this must be a map type id
  227.   MapTypeID& mti = (MapTypeID&) peer_;
  228.   if (!(*ptiKey == *(mti.ptiKey))) {
  229.     return false;
  230.   }
  231.   return ((*ptiValue == *(mti.ptiValue)));
  232. }
  233. void MapTypeID::print(int space) const
  234. {
  235.   TypeID::print(space);
  236.   for (int i=0; i<space; i++) {
  237.     printf(" ");
  238.   }
  239.   printf("MapTypeInfo(%lx): n", (long)this);
  240.   ptiKey->print(space+2);
  241.   ptiValue->print(space+2);
  242. }