Ejemplo n.º 1
0
void Envelope::testMe()
{
   double t0=0, t1=0;

   SetInterpolateDB(false);
   Mirror(false);

   Flatten(0.5);
   checkResult( 1, Integral(0.0,100.0), 50);
   checkResult( 2, Integral(-10.0,10.0), 10);

   Flatten(0.5);
   checkResult( 3, Integral(0.0,100.0), 50);
   checkResult( 4, Integral(-10.0,10.0), 10);
   checkResult( 5, Integral(-20.0,-10.0), 5);

   Flatten(0.5);
   Insert( 5.0, 0.5 );
   checkResult( 6, Integral(0.0,100.0), 50);
   checkResult( 7, Integral(-10.0,10.0), 10);

   Flatten(0.0);
   Insert( 0.0, 0.0 );
   Insert( 5.0, 1.0 );
   Insert( 10.0, 0.0 );
   t0 = 10.0 - .1;
   t1 = 10.0 + .1;
   double result = Integral(0.0,t1);
   double resulta = Integral(0.0,t0);
   double resultb = Integral(t0,t1);
   // Integrals should be additive
   checkResult( 8, result - resulta - resultb, 0);

   Flatten(0.0);
   Insert( 0.0, 0.0 );
   Insert( 5.0, 1.0 );
   Insert( 10.0, 0.0 );
   t0 = 10.0 - .1;
   t1 = 10.0 + .1;
   checkResult( 9, Integral(0.0,t1), 5);
   checkResult( 10, Integral(0.0,t0), 4.999);
   checkResult( 11, Integral(t0,t1), .001);

   WX_CLEAR_ARRAY(mEnv);
   Insert( 0.0, 0.0 );
   Insert( 5.0, 1.0 );
   Insert( 10.0, 0.0 );
   checkResult( 12, NumberOfPointsAfter( -1 ), 3 );
   checkResult( 13, NumberOfPointsAfter( 0 ), 2 );
   checkResult( 14, NumberOfPointsAfter( 1 ), 2 );
   checkResult( 15, NumberOfPointsAfter( 5 ), 1 );
   checkResult( 16, NumberOfPointsAfter( 7 ), 1 );
   checkResult( 17, NumberOfPointsAfter( 10 ), 0 );
   checkResult( 18, NextPointAfter( 0 ), 5 );
   checkResult( 19, NextPointAfter( 5 ), 10 );
}
Ejemplo n.º 2
0
size_t DisplayTags(FILE *fp, Tag *tagList)
{
	size_t len = 0;

	if(tagList)
	{
		Tag *tag;
		len += fprintf(fp, "[");
		
		for(tag = tagList; tag; tag = tag->link)
		{
			len += fprintf(fp, "%s", Parser::inenglish(tag->tok));

			if(tag->expr)
			{
				len += fprintf(fp, "(");
				len += Flatten(fp, tag->expr);
				len += fprintf(fp, ")");
			}

			if(tag->link)
				len += fprintf(fp, ", ");
		}

		len += fprintf(fp, "]");
	}

	return len;
}
Ejemplo n.º 3
0
//
// TPreferences::~TPreferences
//
// Write the preferences to disk.
//
TPreferences::~TPreferences() {
	BFile file;
	
	if (file.SetTo(path.Path(), B_WRITE_ONLY | B_CREATE_FILE) == B_OK) {
		Flatten(&file);
	}
}
status_t
DefaultCatalog::WriteToResource(const entry_ref &appOrAddOnRef)
{
	BFile file;
	status_t res = file.SetTo(&appOrAddOnRef, B_READ_WRITE);
	if (res != B_OK)
		return res;

	BResources rsrc;
	res = rsrc.SetTo(&file);
	if (res != B_OK)
		return res;

	BMallocIO mallocIO;
	mallocIO.SetBlockSize(max(fCatMap.Size() * 20, (int32)256));
		// set a largish block-size in order to avoid reallocs
	res = Flatten(&mallocIO);

	int mangledLanguage = CatKey::HashFun(fLanguageName.String(), 0);

	if (res == B_OK) {
		res = rsrc.AddResource('CADA', mangledLanguage,
			mallocIO.Buffer(), mallocIO.BufferLength(),
			BString(fLanguageName));
	}

	return res;
}
status_t
DefaultCatalog::WriteToFile(const char *path)
{
	BFile catalogFile;
	if (path)
		fPath = path;
	status_t res = catalogFile.SetTo(fPath.String(),
		B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);
	if (res != B_OK)
		return res;

	BMallocIO mallocIO;
	mallocIO.SetBlockSize(max(fCatMap.Size() * 20, (int32)256));
		// set a largish block-size in order to avoid reallocs
	res = Flatten(&mallocIO);
	if (res == B_OK) {
		ssize_t wsz;
		wsz = catalogFile.Write(mallocIO.Buffer(), mallocIO.BufferLength());
		if (wsz != (ssize_t)mallocIO.BufferLength())
			return B_FILE_ERROR;

		// set mimetype-, language- and signature-attributes:
		UpdateAttributes(catalogFile);
	}
	if (res == B_OK)
		UpdateAttributes(catalogFile);
	return res;
}
Ejemplo n.º 6
0
BVH::BVH(ObjMesh& _mesh)
{
    mesh = _mesh;

    //build work list
    workList.reserve(mesh.faces.size());
    for(auto i = 0; i < mesh.faces.size(); ++i)
        workList.push_back(BVHPrimitiveInfo(i, BBox(mesh.vertices[mesh.faces[i].x], mesh.vertices[mesh.faces[i].y], mesh.vertices[mesh.faces[i].z])));

    //recursive build
    std::cout<<"Building BVH..."<<std::endl;
    orderedPrims.reserve(mesh.faces.size());
    root = RecursiveBuild(0, workList.size());
    std::cout<<"Totoal nodes: "<<totalNodes<<std::endl;
    std::cout<<"Max depth: "<<maxDepth<<std::endl;

    //replace mesh faces order with ordered one
    mesh.faces.swap(orderedPrims);

    //build linear bvh
    lbvh.reserve(totalNodes);
    for(auto i = 0; i < totalNodes; ++i)
        lbvh.push_back(LBVHNode());
    uint32_t offset = 0;
    Flatten(root, &offset);
    std::cout<<"Root max: ("<<lbvh[0].bMax.x<<", "<<lbvh[0].bMax.y<<", "<<lbvh[0].bMax.z<<")"<<std::endl;
    std::cout<<"Root min: ("<<lbvh[0].bMin.x<<", "<<lbvh[0].bMin.y<<", "<<lbvh[0].bMin.z<<")"<<std::endl;
}
bool ExprTree::
Flatten( Value& val, ExprTree *&tree ) const
{
	EvalState state;

	state.SetScopes( parentScope );
	return( Flatten( state, val, tree ) );
}
Ejemplo n.º 8
0
Map RasterMapData2( MapData& md )
{
	Map map(md.config.map_width, md.config.map_height);
	Fill( map, Map::BLOCK_SOLID );
	RasterRooms( md.rooms, map );
	RasterPaths( md.rooms, map );
	return Decorate(Flatten(map));
}
Ejemplo n.º 9
0
status_t
BContactField::Flatten(void* buffer, ssize_t size) const
{
	if (buffer == NULL)
		return B_BAD_VALUE;

	BMemoryIO flatData(buffer, size);
	return Flatten(&flatData, size);
}
Ejemplo n.º 10
0
void Preferences::WriteSettings ()
{
	/* Serialize contents of "prefs" to a file on disk */
	RemoveName ("presetVerifyCode");
	AddFloat ("presetVerifyCode", PresetVerifyCode);

	BFile file (prefsPath.Path(), B_CREATE_FILE | B_WRITE_ONLY);
	Flatten (&file);
}
Ejemplo n.º 11
0
bool 
PSettings::Save(const char *file)
{
	BFile out;
	if(out.SetTo(file,B_READ_WRITE|B_CREATE_FILE|B_ERASE_FILE)!=B_OK)return false;
	if(Flatten(&out)!=B_OK)return false;;
	out.Unset();	
	return true;
}
Ejemplo n.º 12
0
int32_t HTTPFormatter::Length(void) 
{
	if (fDirty) 
	{
		Flatten();
	}
	
	return fFlattened.size();
}
 TreeNode * Flatten(TreeNode *r){
     if(r==NULL) return NULL;
     if(r->left==NULL && r->right==NULL) return r;
     
     TreeNode * rr = r->right;
     TreeNode * ll;
     
     if(r->left!=NULL){
         r->right=r->left;
         r->left=NULL;
         ll = Flatten(r->right); 
         if(ll!=NULL) ll->right = rr;
         if(rr==NULL) return ll;
         else return Flatten(rr);
     }else{
         return Flatten(r->right);
     }         
 }
	void Flatten(TreeNode *root)
	{
		if( root != NULL)
		{
			Flatten(root->left);
			Flatten(root->right);

			TreeNode * p = root;
			if( p->left != NULL)
			{
				p = p->left;
				while(p->right) 
					p = p->right;
				p->right = root->right;
				root->right = root->left;
				root->left = NULL;
			}
		}
	}
Ejemplo n.º 15
0
uint32_t BVH::Flatten(BVHNode *node, uint32_t* offset)
{
    LBVHNode* linearNode = &lbvh[*offset];
    linearNode->bMax = node->bounds.bmax;
    linearNode->bMin = node->bounds.bmin;
    uint32_t myOffset = (*offset)++;
    if(node->nPrims > 0)
    {
        linearNode->primitiveOffset = node->firstPrimOffset;
        linearNode->nPrimitives = node->nPrims;
    }
    else
    {
        linearNode->nPrimitives = 0;
        Flatten(node->left, offset);
        linearNode->rightChildOffset = Flatten(node->right, offset);
    }

    return myOffset;
}
	  TreeNode * Flatten(TreeNode *root)
	  {
		  if (root == NULL)
			  return NULL;
		  TreeNode * left = Flatten(root->left);
		  TreeNode * right = Flatten(root->right);
		  if (root->left)
		  {
			  left->right = root->right;
			  root->right = root->left;
		  }
		 
		  root->left = NULL;

		  if (right != NULL)
			  return right;
		  else if (left != NULL)
			  return left;
		  else
			  return root;
	  }
Ejemplo n.º 17
0
void P2PContents::Debug(void) {
	char *buff = Flatten();
	int32 len = FlattenedLength();
	
	for (int32 i = 0; i < len; i++) {
		if ((buff[i] == '\n') || (buff[i] == '\r'))
			printf("%c", buff[i]);
		else if ((buff[i] < 0x20) || (buff[i] > 0x7e))
			printf("0x%x", (unsigned char)buff[i]);
		else
			printf("%c", buff[i]);
	};
};
Ejemplo n.º 18
0
/*!
	\brief Saves the data in the cursor set to a file
	\param path Path of the file to save to.
	\param saveflags BFile open file flags. B_READ_WRITE is implied.
	\return
	- \c B_OK: Everything went fine.
	- \c B_BAD_VALUE: path is NULL
	- \c other value: See BFile::SetTo and BMessage::Flatten return codes
*/
status_t
CursorSet::Save(const char *path, int32 saveFlags)
{
	if (!path)
		return B_BAD_VALUE;

	BFile file;
	status_t status = file.SetTo(path, B_READ_WRITE | saveFlags);
	if (status != B_OK)
		return status;

	return Flatten(&file);
}
Ejemplo n.º 19
0
Archivo: eval.cpp Proyecto: hyln9/nV
bool HandleAttributes(var &result, Var expression, const attr_t &attributes,
						var head, var &body)
{
	if(attributes.count(SequenceHold))
	{
		body = Body(expression);
	}
	else
	{
		body = FlattenSequence(Body(expression), false);
	}
	size_t n = Size(body);
	// FIXME: in mathematica, OneIdentity means "x == f[x]" only for PATTERN MATCHING purposes
// 	if(n == 1 && attributes.count(OneIdentity))
// 	{
// 		result = Eval(At(body,0));
// 		return true;
// 	}
	if(!attributes.count(HoldAll))
	{
		if(n > 0 && !attributes.count(HoldFirst))
			At(body,0) = Eval(At(body,0));
		if(n > 1 && !attributes.count(HoldRest))
			for(size_t i = 1; i < n; ++i)
				At(body,i) = Eval(At(body,i));
	}
	if(attributes.count(Listable))
	{
		// TODO: handle the case where all list must be of same length, e.g. CoprimeQ
		var t = Thread(head,body);
		if(t)
		{
			result = Eval(t);
			return true;
		}
	}
	if(attributes.count(Flat))
	{
		var t = body;
		body = Vec();
		Reserve(body,n);
		Flatten(body,head,t);
	}
	if(attributes.count(Orderless))
		Sort(body);

	return false;
}
Ejemplo n.º 20
0
status_t SettingsFile::Save() const
{
	status_t ret;
	BFile file(path.Path(), B_READ_WRITE | B_CREATE_FILE | B_ERASE_FILE);
	ret = file.InitCheck();
	if (ret !=
		B_OK) { // try to create the parent directory if creating the file fails the first time
		BPath parent;
		ret = path.GetParent(&parent);
		if (ret != B_OK) {
			return ret;
		}
		ret = create_directory(parent.Path(), 0777);
		if (ret != B_OK) {
			return ret;
		}
		ret = file.SetTo(path.Path(), B_READ_WRITE | B_CREATE_FILE | B_ERASE_FILE);
	}
	if (ret != B_OK) {
		return ret;
	}
	ret = file.Lock(); // lock the file to do atomic attribute transactions on it.
	if (ret != B_OK) {
		return ret;
	}

	if (vision_app->fDebugSettings) PrintToStream();

	ret = Flatten(&file);
	if (ret != B_OK) {
		file.Unlock();
		return ret;
	}
	/*
		ret=_StoreAttributes(this,&file);
		if (ret!=B_OK) {
			file.Unlock();
			return ret;
		}
	*/
	file.Unlock();
	return B_OK;
}
Ejemplo n.º 21
0
//	Generate the Hills
//	----------------------------------------------------------------------------
void
generateHillTerrain(FuncParam* param)
{
    m_pMap = param->heightMap;
    m_uXSize = param->xsize ;
    m_uZSize = param->zsize ;
    m_uSeed = param->seed;
    m_uHeightScale  = param->scale;

    // check the parameters
    assert( m_uXSize > 0 );
    assert( m_uZSize > 0 );
    assert( m_uSeed != 0 );
    assert(m_pMap != NULL);

    if(!m_uSeed)
        m_uSeed=1;

    m_fHillMin = 2.0f ;
    m_fHillMax = 40.0f ;
    m_uNumHills = 200;
    m_uFlattening = 1 ;
    m_bIsland = false;

    m_uZSize++ ;
    m_uXSize++;

    Clear();

    // set the seed
    srand( m_uSeed );

    // add as many hills as needed
    for( int i = 0; i < m_uNumHills; ++i )
    {
        AddHill();
    }

    // now clean it up
    Normalize();
    Flatten();
}
Ejemplo n.º 22
0
Preferences::~Preferences()
{
	if (fSavePreferences) {
		BFile file;
		status_t set = B_ERROR;
		if (fSettingsFile)
			file.SetTo(fSettingsFile, B_READ_WRITE | B_CREATE_FILE | B_ERASE_FILE);
		else {
			BPath prefpath;
			if (find_directory(B_USER_SETTINGS_DIRECTORY, &prefpath, true) == B_OK) {
				BDirectory prefdir(prefpath.Path());
				set = prefdir.CreateFile(fName, &file, false);
			}
		}

		if (file.InitCheck () == B_OK) {
			Flatten(&file);
			if (fSignature) {
				file.WriteAttr("BEOS:TYPE", B_MIME_STRING_TYPE, 0, fSignature,
					strlen(fSignature) + 1);
			}
		} else {
			// implement saving somewhere else!
			BString error;
			snprintf(error.LockBuffer(256), 256,
				B_TRANSLATE("Your setting file could not be saved!\n(%s)"),
				strerror(file.InitCheck()));
			error.UnlockBuffer();
			BAlert *alert = new BAlert(B_TRANSLATE("Error saving file"),
				error.String(), B_TRANSLATE("Damned!"), NULL, NULL,
				B_WIDTH_AS_USUAL, B_STOP_ALERT);
			alert->SetShortcut(0, B_ESCAPE);

			alert->Go();
		}
	}
	delete fSettingsFile;
	free(fName);
	free(fSignature);
}
/*
 * this method is not currently being used, but it may be useful in the
 * future...
 */
status_t
DefaultCatalog::WriteToAttribute(const entry_ref &appOrAddOnRef)
{
	BNode node;
	status_t res = node.SetTo(&appOrAddOnRef);
	if (res != B_OK)
		return res;

	BMallocIO mallocIO;
	mallocIO.SetBlockSize(max(fCatMap.Size() * 20, (int32)256));
		// set a largish block-size in order to avoid reallocs
	res = Flatten(&mallocIO);

	if (res == B_OK) {
		ssize_t wsz;
		wsz = node.WriteAttr(BLocaleRoster::kEmbeddedCatAttr, B_MESSAGE_TYPE, 0,
			mallocIO.Buffer(), mallocIO.BufferLength());
		if (wsz < B_OK)
			res = wsz;
		else if (wsz != (ssize_t)mallocIO.BufferLength())
			res = B_ERROR;
	}
	return res;
}
Ejemplo n.º 24
0
/* ********************************************************************** */
void States (const State_1D *state, int beg, int end, Grid *grid)
/*!
 * 
 * \param [in]      state pointer to State_1D structure
 * \param [in]      beg   initial index of computation
 * \param [in]      end   final   index of computation
 * \param [in]      grid  pointer to an array of Grid structures
 *
 ************************************************************************ */
{
  int   i, nv;
  double dv, **v;
  double dvp, cp, *wp, *hp, **vp;
  double dvm, cm, *wm, *hm, **vm;
  PPM_Coeffs ppm_coeffs;
  PLM_Coeffs plm_coeffs;
  
/* ---------------------------------------------------------
   1. Set pointers, compute geometrical coefficients
   --------------------------------------------------------- */

  v  = state->v;
  vm = state->vm;
  vp = state->vp;

  PPM_CoefficientsGet(&ppm_coeffs, g_dir);
  #if SHOCK_FLATTENING == MULTID
   PLM_CoefficientsGet(&plm_coeffs, g_dir);
  #endif

  hp = ppm_coeffs.hp;
  hm = ppm_coeffs.hm;

/* ---------------------------------------------------------
   2. Define unlimited left and right interface values and
      make sure they lie between adjacent cell averages.
   --------------------------------------------------------- */

  #if PPM_VERSION == PPM3 || PPM_VERSION == PPM5
   for (i = beg; i <= end; i++) {
     wp = ppm_coeffs.wp[i];
     wm = ppm_coeffs.wm[i];
     VAR_LOOP(nv){
       #if PPM_VERSION == PPM3
        vp[i][nv] = wp[-1]*v[i-1][nv] + wp[0]*v[i][nv] + wp[1]*v[i+1][nv];
        vm[i][nv] = wm[-1]*v[i-1][nv] + wm[0]*v[i][nv] + wm[1]*v[i+1][nv];
       #elif PPM_VERSION == PPM5
        vp[i][nv] = wp[-2]*v[i-2][nv] + wp[-1]*v[i-1][nv] +  
                    wp[ 0]*v[i][nv]   + wp[ 1]*v[i+1][nv] + wp[ 2]*v[i+2][nv]; 

        vm[i][nv] =  wm[-2]*v[i-2][nv] + wm[-1]*v[i-1][nv] + wm[0]*v[i][nv]
                   + wm[ 1]*v[i+1][nv] + wm[ 2]*v[i+2][nv];
       #endif
       dvp = vp[i][nv] - v[i][nv];
       dvm = vm[i][nv] - v[i][nv];

       dv  = v[i+1][nv] - v[i][nv];
       vp[i][nv] = v[i][nv] + MINMOD(dvp, dv);

       dv  = v[i][nv] - v[i-1][nv];
       vm[i][nv] = v[i][nv] + MINMOD(dvm, -dv);
     }
   }
  #elif PPM_VERSION == PPM4  /* -- set a unique interface value -- */
   for (i = beg-1; i <= end; i++) {
     wp = ppm_coeffs.wp[i];
     VAR_LOOP(nv){
       vp[i][nv] =  wp[-1]*v[i-1][nv] + wp[0]*v[i][nv]
                  + wp[ 1]*v[i+1][nv] + wp[2]*v[i+2][nv];

       dv  = v[i+1][nv] - v[i][nv];
       dvp = vp[i][nv] - v[i][nv];
       vp[i][nv] = v[i][nv] + MINMOD(dvp, dv);
     }
   }
   for (i = beg; i <= end; i++) VAR_LOOP(nv) vm[i][nv] = vp[i-1][nv];
  #endif

/* ---------------------------------------------------------
   3. Apply parabolic limiter: no new extrema should appear
      in the parabola defined by vp, vm and v.
   --------------------------------------------------------- */

  for (i = beg; i <= end; i++) {
    #if SHOCK_FLATTENING == MULTID    
     if (CheckZone (i, FLAG_MINMOD)) {
       wp = plm_coeffs.wp;
       wm = plm_coeffs.wm;
       VAR_LOOP(nv) {
         dvp = (v[i+1][nv] - v[i][nv])*wp[i];
         dvm = (v[i][nv] - v[i-1][nv])*wm[i];
         dv  = MINMOD(dvp, dvm);
         vp[i][nv] = v[i][nv] + dv*plm_coeffs.dp[i];
         vm[i][nv] = v[i][nv] - dv*plm_coeffs.dm[i];
       }
       #if PHYSICS == RHD || PHYSICS == RMHD
        VelocityLimiter (v[i], vp[i], vm[i]);
       #endif
       continue;
     }
    #endif

    #if PPM_VERSION == PPM0
     cm = cp = 2.0;
    #else
     cm = (hm[i] + 1.0)/(hp[i] - 1.0);
     cp = (hp[i] + 1.0)/(hm[i] - 1.0);
    #endif

    for (nv = 0; nv < NVAR; nv++){
      dvp = vp[i][nv] - v[i][nv];
      dvm = vm[i][nv] - v[i][nv];

      if (dvp*dvm >= 0.0) dvp = dvm = 0.0;
      else{
        if      (fabs(dvp) >= cm*fabs(dvm)) dvp = -cm*dvm;
        else if (fabs(dvm) >= cp*fabs(dvp)) dvm = -cp*dvp;
      }
      vp[i][nv] = v[i][nv] + dvp; 
      vm[i][nv] = v[i][nv] + dvm;
    }
    #if PHYSICS == RHD || PHYSICS == RMHD
     VelocityLimiter (v[i], vp[i], vm[i]);
    #endif
  }

/* --------------------------------------------------------
          1D shock flattening
   -------------------------------------------------------- */

  #if SHOCK_FLATTENING == YES
   Flatten (state, beg, end, grid);
  #endif

/*  -------------------------------------------
      Assign face-centered magnetic field
    -------------------------------------------  */

  #ifdef STAGGERED_MHD
   for (i = beg-1; i <= end; i++) {
     state->vR[i][BXn] = state->vL[i][BXn] = state->bn[i];
   }
  #endif

  #if TIME_STEPPING == CHARACTERISTIC_TRACING
   CharTracingStep(state, beg, end, grid);
  #endif

/* -------------------------------------------
    compute states in conservative variables
   ------------------------------------------- */

  PrimToCons (state->vp, state->up, beg, end);
  PrimToCons (state->vm, state->um, beg, end);
}
Ejemplo n.º 25
0
void SODL::WriteSODL(INXString sodlfile) {
	ofstream datafile(sodlfile);
	ConData *blob;
	INXPOSITION pos;
	INXString funcName;
	int funcArg = -1;
	int startFunc = 0;
	UINT i;
	UINT j;
	UINT funcInPortNum = 0, funcOutPortNum = 0, funcFinPortNum = 0;
	// *** lineID is an array of unsigned ints. However, it needs to store the value -1 if
	// a port is not connected. Could use a CArray of type int, but this gives a smaller range
	// of line IDs than using a CUIntArray. Using such an array means -1 is stored as 4294967295.
	// This value should never be reached.
	INXObjArray<unsigned int> lineType;
	CArray<long,long> lineID;
	vector<Group> vGroups;
	TagProjMetaSupportData_t tagData;
	INXString csTargetFileName = "", csMessage = "";

	if (!datafile.good()) {
		AfxMessageBox("File could not be written");
	}
	
	//AfxMessageBox( "Get ready to call Copy2Flattened" );
	// Flatten encapsulated blocks
	Copy2Flattened();

	//AfxMessageBox( "Get ready to call Flatten" );
	Flatten();
	//SaveProg2("tmp.prg");	
	// 1. Assign a unique incremental integer (within its data type) to each line
	//AfxMessageBox( "Get ready to call AssignLineIDNum" );
	AssignLineIDNum();
	// First write the number of groups to the sodl file.
	// Turn off scheduling
	//datafile << 0 << endl;

	//AfxMessageBox( "Get ready to call generate SODL proper" );
	//@todo - add the following datafile << "hashmark" << Project << endl;
/************* The following is where everything is written out. This should be a new function *******************/	
	// Write out the parameters for each group
	WriteVersionInformation(&datafile);
/************ Now add the group data **********************/
	pProject->pProjMData->getGroupVec(vGroups);
	datafile << vGroups.size() << endl;
	

	for (i=0; i<vGroups.size(); i++) {
		datafile << vGroups.at(i).ID << '\t';
		datafile << vGroups.at(i).Period << '\t';
		datafile << vGroups.at(i).Alloc << endl;
	}

	/***** Now add the programme body *******************/
	// 2. For each icon
	pos = flattened->GetHeadPosition();

	while(pos) {

		blob = (ConData *) (flattened->GetNext(pos));

		// check that a startport is connected or an internalport exists or it is the new style constant without a startport
		bool writeObject = FALSE;
		for (i=0; i<blob->startport_num; i++) {
			if (blob->startport[i]->line.exist || blob->startport[i]->initialise) {
				writeObject = true;
			}
		}

		if (blob->internalport_num > 0) {
			writeObject = true;
		}

		if (writeObject) {

			// 3. Write the tag and class name.
			datafile << "BEGIN ";
			datafile << (CString)blob->className << endl;

			// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
			// Write the parameter string.
			// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
			if (blob->iParamNum == 1) {
				datafile << NOPARAMS;

			} else {
				for (i=1; i<blob->iParamNum; i++) {
					// if the parameter is an empty string and there is only 1 parameter 
					// then write out "" else write out "NULL"
					if (blob->iconParam[i]->value == "_") {
						if (blob->iParamNum == 2) {
							datafile << "" << " ";
						}
						else {
							datafile << "NULL" << " ";
						}
					}
					// for string constants don't append a space
					else if (blob->m_csIconType == "const_s") {
							datafile << (CString)blob->iconParam[i]->value;
					}
					// for gui components prepend %%%_
					else if (i==1 && (blob->isGuiWidget())) {
						datafile << "%%%_" << (CString)blob->iconParam[i]->value << " ";
					}
					// for screen tags write out the target filename
					else if (blob->iconParam[i]->dataType == 4) {
						LucidErrEnum err = pProject->pProjMData->getScreenTagMetas((CString &)blob->iconParam[i]->value, tagData);
						assert (err == kErr_NoErr);
						datafile << (CString)tagData.tgtFilename << " ";
					}
					// write out target filename for data files
					else if (blob->m_csIconType.Find("file_ro") != -1 && blob->iconParam[i]->name == "File name") {
						if (pProject->pProjMData->getTargetFileNameForDataHostFileName(blob->iconParam[i]->value, csTargetFileName)) {
							csMessage.Format("File \"%s\" does not exist in the project. Your application may not work as expected.", blob->iconParam[i]->value);
							// Don't display message because IPlayer demo runs a script which relies on host filenames
							//AfxMessageBox(csMessage);
							datafile << (CString)blob->iconParam[i]->value << " ";
						}
						else {
							datafile << (CString)csTargetFileName << " ";
						}
					}
					else {
						datafile << (CString)blob->iconParam[i]->value << " ";
					}

				}

			} // (blob->iParamNum != 1)

			// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
			// <ENDOF> Write the parameter string.
			// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!


			datafile << endl;
			// 5. Write the tag to begin listing functions


			// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
			// For each start trigger port
			// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

			for (i=0; i<blob->startport_num; i++) {

				funcInPortNum = 0; funcOutPortNum = 0, funcFinPortNum = 0;
				// if the start port is initialised SODL requires a start function
				if (blob->startport[i]->initialise) {
					startFunc = 1;
				}
				// if the start port is connected or initialised
				if (blob->startport[i]->line.exist || blob->startport[i]->initialise) {
					// 7.1 Write its function name. Is there only 1 function?
					funcName = blob->startport[i]->funcName->GetAt(0);
					datafile << (CString)funcName << '\t';
					// Write out atomic flag
					//datafile << blob->startport[i]->atomicFlag << '\t';
					datafile << 1 << '\t';
					// Write out group ID for start port
					datafile << blob->startport[i]->groupID << '\t';
					// Write out start trigger line ID
					datafile << blob->startport[i]->line.idNum << '\t';
					// 7.2 Search through all other ports to find any other references
					// to the function name
					lineID.RemoveAll();
					lineType.RemoveAll();
					for (j=0; j<blob->inputport_num; j++) {
						for (int k=0; k<blob->inputport[j]->funcName->GetSize(); k++) {
							if (blob->inputport[j]->funcName->GetAt(k) == funcName) {
								funcInPortNum++;
								funcArg = blob->inputport[j]->funcArg->GetAt(k);
								//store the line id and type in a temp. array
								// check if a line is connected
								if (blob->inputport[j]->line.exist) {
									lineID.SetAtGrow(funcArg, blob->inputport[j]->line.idNum);
								}
								else {
									lineID.SetAtGrow(funcArg, -1);		
								}
								lineType.SetAtGrow(funcArg, blob->inputport[j]->datatype);
							}
						}
					}

					// write out inputs
					datafile << funcInPortNum << " ";
					for (j=1; j<=funcInPortNum; j++) {
						datafile << convert.DataType2Char(lineType.GetAt(j)) << " ";
						// Originally wrote out a * for uncoonected ports. Now writes out -1.
						/*if (lineID.GetAt(j) == -1) {
							datafile << "* ";
						}
						else {*/
							datafile << lineID.GetAt(j) << " ";
						//}
					}

					for (j=0; j<blob->outputport_num; j++) {
						for (int k=0; k<blob->outputport[j]->funcName->GetSize(); k++) {
							if (blob->outputport[j]->funcName->GetAt(k) == funcName) {
								funcOutPortNum++;
								funcArg = blob->outputport[j]->funcArg->GetAt(k);
								//store the line id and type in a temp. array
								// check if a line is connected
								if (blob->outputport[j]->lineID > -1) {
									lineID.SetAtGrow(funcArg, blob->outputport[j]->lineID);
								}
								else {
									lineID.SetAtGrow(funcArg, -1);
								}
								lineType.SetAtGrow(funcArg, blob->outputport[j]->datatype);
							}
						}
					}
					
					// write out outputs
					datafile << '\t' << funcOutPortNum << " ";
					for (j=(funcInPortNum + 1); j<=(funcInPortNum + funcOutPortNum); j++) {
						datafile << convert.DataType2Char(lineType.GetAt(j)) << " ";
						datafile << lineID.GetAt(j) << " ";
					}
					
					for (j=0; j<blob->finishport_num; j++) {
						for (int k=0; k<blob->finishport[j]->funcName->GetSize(); k++) {
							if (blob->finishport[j]->funcName->GetAt(k) == funcName) {
								funcFinPortNum++;
								funcArg = blob->finishport[j]->funcArg->GetAt(k);
								//store the line id and type in a temp. array
								// check if a line is connected
								if (blob->finishport[j]->lineID > -1) {
									lineID.SetAtGrow(funcArg, blob->finishport[j]->lineID);
								}
								else {
									lineID.SetAtGrow(funcArg, -1);
								}
							}
						}
					}
					// write out finish ports
					datafile << '\t' << funcFinPortNum << " ";
					// Only write out the finish line numbers if there is at least one connection
					if (funcFinPortNum > 0) {
						for (int m=(funcInPortNum + funcOutPortNum + 1); m<lineID.GetSize(); m++) {
							datafile << lineID.GetAt(m) << " ";
						}
					}
					
					datafile << endl;
				}
			}
			// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
			// <ENDOF> For each start trigger port
			// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!



			// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
			// For each internal trigger port
			// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

			for (i=0; i<blob->internalport_num; i++) {
				funcInPortNum = 0; funcOutPortNum = 0, funcFinPortNum = 0;
				// ***REVISIT. Write its function name. Is there only 1 function?
				funcName = blob->internalport[i]->funcName->GetAt(0);
				datafile << (CString)funcName << '\t';
				// Write out atomic flag
				//datafile << blob->internalport[i]->atomicFlag << '\t';
				datafile << 1 << '\t';
				// Write out group ID for internal port
				datafile << blob->internalport[i]->groupID << '\t';
				// The internal trigger does not have a line ID so write out 0 if it is the
				// Start function and -1 otherwise.
				if (funcName == START) {
					datafile << 0 << '\t';
				}
				else {
					datafile << -1 << '\t';
				}
				// 7.2 Search through all other ports to find any other references
				// to the function name
				lineID.RemoveAll();
				lineType.RemoveAll();
				for (j=0; j<blob->inputport_num; j++) {
					for (int k=0; k<blob->inputport[j]->funcName->GetSize(); k++) {
						if (blob->inputport[j]->funcName->GetAt(k) == funcName) {
							funcInPortNum++;
							funcArg = blob->inputport[j]->funcArg->GetAt(k);
							//store the line id and type in a temp. array
							// check if a line is connected
							if (blob->inputport[j]->line.exist) {
								lineID.SetAtGrow(funcArg, blob->inputport[j]->line.idNum);
							}
							else {
								lineID.SetAtGrow(funcArg, -1);		
							}
								lineType.SetAtGrow(funcArg, blob->inputport[j]->datatype);
						}
					}
				}
				// write out inputs
				datafile << funcInPortNum << " ";
				for (j=1; j<=funcInPortNum; j++) {
					datafile << convert.DataType2Char(lineType.GetAt(j)) << " ";
					datafile << lineID.GetAt(j) << " ";
				}

				for (j=0; j<blob->outputport_num; j++) {
					for (int k=0; k<blob->outputport[j]->funcName->GetSize(); k++) {
						if (blob->outputport[j]->funcName->GetAt(k) == funcName) {
							funcOutPortNum++;
							funcArg = blob->outputport[j]->funcArg->GetAt(k);
							//store the line id and type in a temp. array
							// check if a line is connected
							if (blob->outputport[j]->lineID > -1) {
								lineID.SetAtGrow(funcArg, blob->outputport[j]->lineID);
							}
							else {
								lineID.SetAtGrow(funcArg, -1);
							}
							lineType.SetAtGrow(funcArg, blob->outputport[j]->datatype);
						}
					}
				}
					
				// write out outputs
				datafile << '\t' << funcOutPortNum << " ";
				for (j=(funcInPortNum + 1); j<=(funcInPortNum + funcOutPortNum); j++) {
					int tmp = lineType.GetAt(j);
					datafile << convert.DataType2Char(lineType.GetAt(j)) << " ";
					datafile << lineID.GetAt(j) << " ";
				}
					
				for (j=0; j<blob->finishport_num; j++) {
					for (int k=0; k<blob->finishport[j]->funcName->GetSize(); k++) {
						if (blob->finishport[j]->funcName->GetAt(k) == funcName) {
							funcFinPortNum++;
							funcArg = blob->finishport[j]->funcArg->GetAt(k);
							//store the line id and type in a temp. array
							// check if a line is connected
							if (blob->finishport[j]->lineID > -1) {
									lineID.SetAtGrow(funcArg, blob->finishport[j]->lineID);
							}
							else {
								lineID.SetAtGrow(funcArg, -1);
							}
						}
					}
				}
				// write out finish ports
				datafile << '\t' << funcFinPortNum << " ";
				for (int m=(funcInPortNum + funcOutPortNum + 1); m<lineID.GetSize(); m++) {
					datafile << lineID.GetAt(m) << " ";
				}		
				datafile << endl;
			}
			// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
			// <ENDOF> For each internal trigger port
			// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!


			// 8. Write out end of icon tags
			datafile << "END" << endl;
			//datafile << endl;

		} //if (writeObject)
	}
	// Always Write out start function -- even if no other functions need initialising.
	//if (startFunc) {
		datafile << "BEGIN Start" << endl;
		datafile << "*" << endl;
		datafile << "Run_Start	1	1	0	0 	0 	1 1" << endl;
		datafile << "END" << endl;
	//}
	datafile.close();
}
Ejemplo n.º 26
0
int32 P2PContents::FlattenedLength(void) {
	if (fDirty) Flatten();
	
	return fFlattened.BufferLength();
};
Ejemplo n.º 27
0
bool LevelHandler::Load(const char filePath[])
{
    
    for(int q=0; q<128; q++)
    {
        for(int w=0; w<128; w++)
        {
            f[q][w]=0;
        }
    }
    
    Flatten(1);
    
    for(int e=0; e<16; e++)
    {
        enemy[e][0]=64;
        enemy[e][1]=64;
    }
    
    if(filePath[0]!=NULL)
    {
        FILE *filein;
        int errnum;
        filein=fopen(filePath, "rt");
        
        //Error checking
        if(!filein)
        {
            //Error Logging goes here.
            std::cerr << "LevelHandler: failed to open file:" << filePath << std::endl;
            errnum = errno;
            fprintf(stderr, "Value of errno: %d\n", errno);
            perror("Error printed by perror");
            fprintf(stderr, "Error opening file: %s\n", strerror( errnum ));
            
            char path[1024];
            uint32_t size = sizeof(path);
            if (_NSGetExecutablePath(path, &size) == 0)
                printf("executable path is %s\n", path);
            else
                printf("buffer too small; need size %u\n", size);
            return false;
        }
        else
        {
            //fileName=new char[Strlen(filePath)+1];
            //fileName[Strlen(filePath)]='\n';
            
            for(int k=Strlen(filePath); k>-1; k--)
            {
                fileName[k]=filePath[k];
            }
            
            //These two lines get the map size
            //The last two characters in the file's name are the map's size.
            //Ex:
            //[email protected]
            //That means that sizeX=64 and sizeZ=48
            //This is not yet implimented because we're using static arrays
            
            //sizeX=2*filePath[Strlen(filePath)-6];
            
            //sizeZ=2*filePath[Strlen(filePath)-5];
            
            sizeX=128;
            sizeZ=128;
            
            //			TankHandler::GetSingleton().numberTanks=sizeX/16;
            
            
            
            /*
             
             t = new int*[sizeX];
             
             
             //Recall that ap[i] is a pointer to an array of int's
             t[0]=new int[sizeX*sizeZ];
             // This "connects" the array of pointers to the arrays of ints
             for (int m=1;m<sizeX;m++)
             {
             t[m]=t[m-1]+sizeZ;
             }*/
            
            
            
            int cdepth=sizeZ;
            char* oneline = new char[cdepth];	//Storage per line
            //Get first line
            //fgets(oneline, cdepth, filein);
            
            for(int i=0; i<sizeX; i++)
            {
                //Get next line
                fgets(oneline, cdepth, filein);
                for(int j=0; j<sizeZ; j++)
                {
                    t[i][j]=oneline[j];
                    
                    if(t[i][j]==33)
                    {
                        start[0]=i;
                        start[1]=j;
                        t[i][j]=t[i-1][j];
                    }
                    else
                        if(t[i][j]>=48 && t[i][j]<58)
                        {
                            enemy[t[i][j]-48][0]=i;
                            enemy[t[i][j]-48][1]=j;
                            t[i][j]=t[i-1][j];
                        }
                        else
                        {
                            t[i][j]=oneline[j]-100;
                            
                            if(t[i][j]==-1)
                            {
                                if(App::GetSingleton().gameTask->versus)
                                {
                                    t[i][j]=10;
                                }
                                else
                                {
                                    t[i][j]=-20;
                                }
                            }
                            
                            
                            if(t[i][j]>26)
                                t[i][j]=0;
                            if(i==0 || i==(sizeX-1) || j==0 || j==(sizeZ-1))
                                t[i][j]=26;
                        }
                }
                fgets(oneline, cdepth, filein);
            }
            
            delete [] oneline;
            
            fclose(filein);
            return true;
        }
    }
    
    
    levelNumber=fileName[5];
    
    
    return false;
}
Ejemplo n.º 28
0
void RequestParser::Test() {
  assert(ExtractMethod("GET / HTTP1.1") == GET);
  assert(ExtractMethod("HEAD / HTTP1.1") == HEAD);
  assert(ExtractMethod("POST / HTTP1.1") == POST);
  assert(ExtractMethod("Error / HTTP1.1") == UNKNOWN);

  assert(ExtractTarget("GET / HTTP1.1") == "");
  assert(ExtractTarget("GET // HTTP1.1") == "");
  assert(ExtractTarget("GET /// HTTP1.1") == "");
  assert(ExtractTarget("GET /dir/file.txt HTTP1.1") == "dir/file.txt");
  assert(ExtractTarget("GET /dir/file.txt?params HTTP1.1") == "dir/file.txt");
  assert(ExtractTarget("GET /?params HTTP1.1") == "");
  assert(ExtractTarget("GET //?params HTTP1.1") == "");

  assert(Flatten(ExtractQueryParams("GET / HTTP1.1")) == "");

  assert(Flatten(ExtractQueryParams("GET // HTTP1.1")) == "");
  assert(Flatten(ExtractQueryParams("GET /// HTTP1.1")) == "");
  assert(Flatten(ExtractQueryParams("GET /dir/file.txt HTTP1.1")) == "");
  assert(Flatten(ExtractQueryParams("GET /dir/file.txt? HTTP1.1")) == "");
  assert(Flatten(ExtractQueryParams("GET /dir/file.txt?params HTTP1.1")) == "params=''");
  assert(Flatten(ExtractQueryParams("GET /dir/file.txt?param1&param2&param3 HTTP1.1")) == "param1='' param2='' param3=''");
  assert(Flatten(ExtractQueryParams("GET /dir/file.txt?param1=val1&param2=val2&param3=val3 HTTP1.1")) == "param1='val1' param2='val2' param3='val3'");
  assert(Flatten(ExtractQueryParams("GET /?params HTTP1.1")) == "params=''");
  assert(Flatten(ExtractQueryParams("GET /? HTTP1.1")) == "");
  assert(Flatten(ExtractQueryParams("GET //?params HTTP1.1")) == "params=''");

  assert(TestRange(true, "Range: bytes=0-1024", 0, 1024));
  assert(TestRange(false, "Range: time=0-1024", 0, 0));
  assert(TestRange(true, "Range: bytes=0-", 0, -1));
  assert(TestRange(true, "Range: bytes=1024-", 1024, -1));
  assert(TestRange(true, "Range: bytes=232128512-", 232128512, -1));
}
	void flatten(TreeNode *root) {
		// Start typing your C/C++ solution below
		// DO NOT write int main() function

		Flatten(root);
	}
	  void flatten(TreeNode *root) {
		  Flatten(root);
	  }