void AggregationVisualizerNode::expand(VariableNode* a_pVariableNode, const vector<reflection::Expression*>& a_LeftExpressions) const 
{
    a_pVariableNode->setDelegate(o_new(AggregationVariableNodeDelegate));
    vector<vector<reflection::Expression*>> groupedVariables;
    for(size_t i = 0; i<a_LeftExpressions.size(); ++i)
    {
        reflection::Expression* pLeftExpression = a_LeftExpressions[i];
        reflection::AggregationClass* pAggregationClass = as<reflection::AggregationClass*>(pLeftExpression->getValueType()->removeReference());
        o_assert(pAggregationClass);
        vector<reflection::Expression*> signature;
        reflection::Expression* pSizeExpression = cplusplus()->qualifiedLookup(pLeftExpression->clone(), "count", nullptr, &signature)->asExpression();
        bool ok;
        size_t count = pSizeExpression->get().as<size_t>(&ok);
        o_assert(ok);

        groupedVariables.resize(std::max(groupedVariables.size(), count));
        for(size_t i = 0; i<count; ++i)
        {
            reflection::Expression* pIndexExpression = o_new(reflection::ConstantExpression)(constant<size_t>(i));
            reflection::Expression* pExpression = cplusplus()->solveBinaryOperator("[]", pLeftExpression->clone(), pIndexExpression);
            o_assert(pExpression);
            groupedVariables[i].push_back(pExpression);
        }
        o_dynamic_delete pSizeExpression;
    }
    size_t i = 0;
    for(;i<groupedVariables.size(); ++i)
    {
        VariableNode* pChild = o_new(VariableNode)(lexical_cast<string>(i), groupedVariables[i]);
        pChild->setDelegate(o_new(AggregationAggregateVariableNodeDelegate)(i, groupedVariables.size()));
        a_pVariableNode->addChildNode(pChild);
    }
}
Beispiel #2
0
Expression* Expression::dereference() const
{
    DataPointerType* pPointerType = m_pValueType->asDataPointerType();
    Expression* args[2] = { (Expression*)this, 0 };
    if(pPointerType == nullptr) 
        return o_new(BuiltInOperatorExpression)( application()->getBuiltInOperator(e_Operator_Dereference), Type::Invalid(), args, operation_delegate_t()); 
    return o_new(BuiltInOperatorExpression)(application()->getBuiltInOperator(e_Operator_Dereference), pPointerType->removePointer()->addLValueReference(), args, operation_delegate_t(pPointerType, &DataPointerType::dereference));
}
Beispiel #3
0
Expression* Expression::address() const
{
    ReferenceType* pReferenceType = m_pValueType->asReferenceType();
    Expression* args[2] = { (Expression*)this, 0 };
    if(pReferenceType == nullptr) 
        return o_new(BuiltInOperatorExpression)(application()->getBuiltInOperator(e_Operator_Address), Type::Invalid(), args, operation_delegate_t()); 
    return o_new(BuiltInOperatorExpression)(application()->getBuiltInOperator(e_Operator_Address), pReferenceType->removeReference()->addPointer(), args, operation_delegate_t(pReferenceType, &ReferenceType::address));
}
VirtualMemberFunctionTable* VirtualMemberFunctionTable::derive(size_t a_uiSize  /*= 0*/) const
{
    if(a_uiSize == 0 OR a_uiSize == m_pMemberFunctions->size())
    {
        return o_new(VirtualMemberFunctionTable)(const_cast<VirtualMemberFunctionTable*>(this));
    }
    o_assert(a_uiSize > m_pMemberFunctions->size());
    return o_new(VirtualMemberFunctionTable)(const_cast<VirtualMemberFunctionTable*>(this), a_uiSize);
}
Beispiel #5
0
Expression* Expression::arrayAccess( Expression* a_pIndexExpression )
{
    ReferenceType* pReferenceType = m_pValueType->asReferenceType();
    Expression* args[2] = { (Expression*)this, a_pIndexExpression };
    if(pReferenceType == nullptr 
        OR pReferenceType->getReferencedType()->asArrayType() == nullptr 
        OR pReferenceType->getReferencedType()->asDataPointerType() == nullptr) 
        return o_new(BuiltInOperatorExpression)(application()->getBuiltInOperator(e_Operator_Bracket), Type::Invalid(), args, operation_delegate_t()); 
    Type* pElementType = pReferenceType->getReferencedType()->getUnderlyingType();
    Type* pResultType = pReferenceType->asRValueReferenceType() ? (Type*)pElementType->rvalueReferenceType() : pElementType->lvalueReferenceType();
    return o_new(BuiltInOperatorExpression)(application()->getBuiltInOperator(e_Operator_Bracket), pResultType, args, operation_delegate_t(pElementType->pointerType(), &DataPointerType::bracket));
}
Beispiel #6
0
Expression* Expression::store( Expression* a_pRightExpression )
{
    ReferenceType* pReferenceType = m_pValueType->asReferenceType();
    Expression* args[2] = { (Expression*)this, a_pRightExpression };
    if(pReferenceType == nullptr 
        OR pReferenceType->getReferencedType()->asClassType() 
        OR pReferenceType->getReferencedType()->isConst()
        OR NOT(a_pRightExpression->getValueType()->equals(pReferenceType->getReferencedType()))) 
        return o_new(BuiltInOperatorExpression)(application()->getBuiltInOperator(e_Operator_Assignment), Type::Invalid(), args, operation_delegate_t()); 
    Type* pElementType = pReferenceType->getReferencedType()->getUnderlyingType();
    Type* pResultType = pReferenceType->asRValueReferenceType() ? (Type*)pElementType->rvalueReferenceType() : pElementType->lvalueReferenceType();
    return o_new(BuiltInOperatorExpression)(application()->getBuiltInOperator(e_Operator_Assignment), pResultType, args, operation_delegate_t(pReferenceType, &ReferenceType::memcpyStoreDelegate));
}
void ClassTypeVisualizerNode::expand( VariableNode* a_pParentNode, const vector<reflection::Expression*>& a_LeftExpressions, reflection::ClassType* a_pClassType) const
{
    // Public Value Members (Properties and InstanceAttributes
    {
        auto it = a_pClassType->beginValueMembers();
        auto end = a_pClassType->endValueMembers();
        for(;it != end;++it)
        {
            reflection::ValueMember* pValueMember = *it;
            if(!m_Filter(a_pParentNode, pValueMember)) 
                continue;
            vector<reflection::Expression*> expressions;
            for(auto it = a_LeftExpressions.begin(); it != a_LeftExpressions.end(); ++it)
            {
                reflection::Expression* pLeftExpression = *it;
                expressions.push_back(cplusplus()->qualifiedLookup(pLeftExpression->clone(), pValueMember->getName(), nullptr, nullptr, 0)->asExpression());
            }
            VariableNode* pVariableNode = o_new(VariableNode)(nameOf(pValueMember), expressions);
            pVariableNode->setIcon(QIcon(iconOf(pValueMember).c_str()));
            pVariableNode->setRange(pValueMember->getRange());
            pVariableNode->setModifiers(pValueMember->getModifiers());
            a_pParentNode->addChildNode(pVariableNode);
        }
    }
}
Beispiel #8
0
void Expression::ancestorChanged( LanguageElement* a_pLanguageElement )
{
    if(getEnclosingBlock())
    {
        Class* pClass = getValueType()->removeRValueReference()->asClass();
        if(pClass)
        {
            void* pStorageAddress = evalStorage();
            o_assert(pStorageAddress);
            Expression* pThis = (o_new(ConstantExpression)(phantom::constant<void*>(pStorageAddress)))->convert(getValueType()->pointerType())->dereference();
            Statement* pLifeTimeStatement = evaluateLifeTime();
            o_assert(pLifeTimeStatement);
            CallExpression* pDestructionExpression = o_new(CallExpression)(getValueType()->asClass()->getDestructor(), pThis);
            pLifeTimeStatement->addTemporaryObjectDestruction(pDestructionExpression);
        }
    }
}
Beispiel #9
0
void CullSystem::BuildOctTree( TreeNode<VisCell>& node )
{
	if (node.GetDepth() == m_Depth )
	{
		return;
	}
	
	node.GetChildren().resize(8);
	for( int i = 0 ;i<8; i++ )
	{
		node.GetChildren()[i] = o_new( TreeNode<VisCell> );
		node.GetChildren()[i]->SetParent( &node );
		node.GetChildren()[i]->SetDepth( node.GetDepth()+1 );
		node.GetChildren()[i]->SetIndex(i);

		VisCell& parentCell = node.GetContent();
		aabbox&   box = parentCell.GetAABB();
		aabbox    baseBox;		
		
		point middle = (box.GetMax()+box.GetMin())*0.5f;
		float xHalf = box.GetMax().X() - middle.X();
		float yHalf	= box.GetMax().Y() - middle.Y();
		float zHalf	= box.GetMax().Z() - middle.Z();

		baseBox.SetMax( box.GetMax() );
		baseBox.SetMin( middle );

		point& pMax = baseBox.GetMax();
		point& pMin = baseBox.GetMin();

		if ( i%2==1 )
		{
			 pMax.X()-=xHalf; 
			 pMin.X()-=xHalf; 
		}
		if ( i>=4 )
		{
			pMax.Y()-=yHalf; 
			pMin.Y()-=yHalf; 

			if (i>=6)
			{
				pMax.Z()-=zHalf; 
				pMin.Z()-=zHalf;
			}
		}
		else if( i>=2 )
		{
			pMax.Z()-=zHalf; 
			pMin.Z()-=zHalf;
		}

		VisCell& childCell = node.GetChildren()[i]->GetContent();
		childCell.SetAABB(baseBox);
		BuildOctTree( *node.GetChildren()[i]);
		
	}
}
Beispiel #10
0
int main() {
	orientdb *oh;
	orientdb_con *oc;
	struct timeval tv;
	
	int rc;
	char str[O_ERR_MAXLEN];
	long x;
	
	oh = o_new();
	o_debug_setlevel(oh, ORIENT_DEBUG);
	o_debug_sethook(oh, &my_debug);
	
	//rc = o_prepare_connection(oh, ORIENT_PROTO_BINARY, "192.168.1.100", "2424");
	rc = o_prepare_connection(oh, ORIENT_PROTO_BINARY, "127.0.0.1", "2424");
	if (rc != O_OK) {
		o_strerr(rc, str, O_ERR_MAXLEN); 
		fprintf(stderr, "Error preparing connections (%i): %s\n", rc, str);
		o_free(oh);
		return rc;
	}
	
	// this user will be used to execute administrative commands to orientdb
	rc = o_prepare_user(oh, ORIENT_ADMIN, "root", "test");
	// this user will be used on database open to execute commands to the db
	rc = o_prepare_user(oh, ORIENT_USER, "admin", "admin");
	
	// set a connection timeout of 5 seconds
	tv.tv_sec = 5;
	tv.tv_usec = 0;
	// try to create the connection with orientdb. NULL if a problem is encountered 
	oc = o_connect(oh, &tv, 0);
	if (!oc) {
		o_free(oh);
		return 1;
	}
	
	// set a connection timeout of 5 seconds
	tv.tv_sec = 15;
	tv.tv_usec = 0;
	//rc = bin_dbopen(oh, oc, &tv, 0, "demo");
	rc = o_bin_dbopen(oh, oc, &tv, 0, "test");
	
	tv.tv_sec = 15;
	tv.tv_usec = 0;
	x = o_bin_dataclustercount(oh, oc, &tv, 0, 6);
	fprintf(stderr, "Cluster count: %ld\n", x);
	
	tv.tv_sec = 15;
	tv.tv_usec = 0;
	rc = o_bin_dbclose(oh, oc, &tv, 0);
	
	o_close(oh, oc);
	o_free(oh);
	
	return 0;
}
Beispiel #11
0
Expression* Expression::convert( Type* a_pOutputType, int conversionType /*= e_implicit_conversion*/, LanguageElement* a_pContextScope ) const
{
    if(a_pOutputType->removeQualifiers()->equals(m_pValueType->removeQualifiers()) && conversionType == e_implicit_conversion)
        return const_cast<Expression*>(this);
    conversion* conv = getValueType()->conversionTo(a_pOutputType, conversionType, a_pContextScope);
    if(conv == nullptr) return o_new(BuiltInConversionExpression)(const_cast<Expression*>(this), nullptr, conversionType);
    Expression* pConversion = conv->convert(const_cast<Expression*>(this));
    o_assert(pConversion);
    delete conv;
    return pConversion;
}
void AggregationClass::fetchExpressions( Expression* a_pInstanceExpression, vector<Expression*>& out, filter a_Filter, uint a_uiSerializationMask ) const
{
    if(a_Filter(getAggregateClass()->pointerType()))
    {
        void* pInstance = a_pInstanceExpression->loadEffectiveAddress();
        size_t count = this->count(pInstance);
        for(size_t i = 0; i<count; ++i)
        {
            out.push_back(o_new(AggregationInsertRemoveExpression)(a_pInstanceExpression, o_new(ConstantExpression)(phantom::constant<size_t>(i)), const_cast<AggregationClass*>(this)));
        }
    }
}
Beispiel #13
0
void GraphicMgr::Init()
{
	// here we will init the current pipeline and cull sys;
	m_pPipeline = o_new(FixedRenderPipeline);
	m_pPipeline->Init();

	m_pRenderer = o_new(FixedRenderer);//hack
	for (int i = 0;i<RENDERTYPECOUNT;i++)
	{
		m_RenderableArries.push_back(std::list<Ptr<Renderable>>());
	}


	// here we will setup the culling system
	m_pCullSystem = o_new(CullSystem);
	m_pCullSystem->SetDepth(3);
	aabbox cullArea;
	cullArea.SetMax(point( 500.f, 500.f, 500.f,1.f));
	cullArea.SetMin(point(-500.f,-500.f,-500.f,1.f));
	m_pCullSystem->SetCullArea(cullArea);
	m_pCullSystem->Init();

}
VariableWidgetEditor* ComponentVariableNodeDelegate::createEditor() const
{
    reflection::ComponentClass* pComponentClass = m_pVariableNode->getValueType()->removeConstReference()->asComponentClass();
    vector<reflection::Class*> currentClasses;
    size_t count = m_pVariableNode->getExpressionCount();
    reflection::Class* pCurrentClass = nullptr;
    for(size_t i = 0; i<count; ++i)
    {
        void* pOldValue = nullptr;
        pComponentClass->get(m_pVariableNode->getExpression(i)->loadEffectiveAddress(), &pOldValue);
        if(pOldValue)
        {
            reflection::Class* pClass = classOf(pOldValue);
            if(pCurrentClass != nullptr AND pClass != pCurrentClass)
            {
                pCurrentClass = nullptr;
                break;
            }
            pCurrentClass = pClass;
        }
    }
    return o_new(ClassComboBoxEditor)(pComponentClass->getPointedClass(), pCurrentClass, NOT(m_pVariableNode->hasModifier(o_mandatory)));
}
Beispiel #15
0
	void	Vision::feel_vision_update	(CObject* parent, Fvector& P, float dt, float vis_threshold)
	{
		// B-A = objects, that become visible
		if (!seen.empty()) 
		{
			xr_vector<CObject*>::iterator E		= std::remove(seen.begin(),seen.end(),parent);
			seen.resize			(E-seen.begin());

			{
				diff.resize	(_max(seen.size(),query.size()));
				xr_vector<CObject*>::iterator	E = std::set_difference(
					seen.begin(), seen.end(),
					query.begin(),query.end(),
					diff.begin() );
				diff.resize(E-diff.begin());
				for (u32 i=0; i<diff.size(); i++)
					o_new(diff[i]);
			}
		}

		// A-B = objects, that are invisible
		if (!query.empty()) 
		{
			diff.resize	(_max(seen.size(),query.size()));
			xr_vector<CObject*>::iterator	E = std::set_difference(
				query.begin(),query.end(),
				seen.begin(), seen.end(),
				diff.begin() );
			diff.resize(E-diff.begin());
			for (u32 i=0; i<diff.size(); i++)
				o_delete(diff[i]);
		}

		// Copy results and perform traces
		query				= seen;
		o_trace				(P,dt,vis_threshold);
	}
RemoveDataCommand::RemoveDataCommand(serialization::DataBase* a_pDataBase, const vector<uint>& a_Guids)
: DataBaseCommand(a_pDataBase)
{
    m_Guids = a_Guids;
    setName("Remove");
    vector<phantom::data> allData;
    m_pDataBase->rootNode()->fetchDataCascade(allData);
    for(size_t i = 0; i<m_Guids.size(); ++i)
    {
        phantom::data d = m_pDataBase->getData(m_Guids[i]);
        o_assert(!d.isNull());
        for(auto it = allData.begin(); it != allData.end(); ++it)
        {
            if(m_pDataBase->getComponentDataOwner(*it) == d)
                m_Guids.push_back(m_pDataBase->getGuid(*it));
        }
    }
    std::sort(m_Guids.begin(), m_Guids.end());
    m_Guids.resize(std::unique(m_Guids.begin(), m_Guids.end())-m_Guids.begin());
    for(auto it = m_Guids.begin(); it != m_Guids.end(); ++it)
    {
        pushCommand(o_new(UndoCommand)((m_pDataBase->getNode(*it) ? "Node '" : "Data '") + m_pDataBase->getAttributeValues(m_pDataBase->getData(*it).address())[0] + "' ("+lexical_cast<string>((void*)(*it))+")" ));
    }
}
 void FlagsVisualizerNode::expand( VariableNode* a_pParent, const vector<reflection::Expression*>& a_LeftExpressions ) const
 {
     map<reflection::Constant*, vector<reflection::Expression*>> flagsExpressions;
     for(auto it = a_LeftExpressions.begin(); it != a_LeftExpressions.end(); ++it)
     {
         reflection::Expression* pLeftExpression = *it;
         if(NOT(pLeftExpression->hasEffectiveAddress())) continue;
         reflection::Enum* pEnum = pLeftExpression->getValueType()->removeReference()->removeConst()->getOwner()->asTemplateSpecialization()->getArgument("Enum")->asEnum();
         for(size_t i = 0; i<pEnum->getConstantCount(); ++i)
         {
             flagsExpressions[pEnum->getConstant(i)].push_back(
                 cplusplus()->qualifiedLookup(
                     cplusplus()->solveBinaryOperator("[]", pLeftExpression->clone(), o_new(reflection::ConstantExpression)(pEnum->getConstant(i)))
                 , "value", nullptr, nullptr, 0)->asExpression()
             );
         }
     }
     for(auto it = flagsExpressions.begin(); it != flagsExpressions.end(); ++it)
     {
         VariableNode* pNode = o_new(VariableNode)(nameOf(it->first), it->second);
         pNode->setIcon(QIcon(iconOf(it->first).c_str()));
         a_pParent->addChildNode(pNode);
     }
 }
Beispiel #18
0
int main() {
	orientdb *oh;
	orientdb_con *oc;
	struct timeval tv;
	
	ODOC_OBJECT *odoc;
	
	int rc;
	char str[O_ERR_MAXLEN];
	long position;
	
	int i;
	
	oh = o_new();
	o_debug_setlevel(oh, ORIENT_DEBUG);
	//o_debug_setlevel(oh, ORIENT_CRITICAL);
	o_debug_sethook(oh, &my_debug);
	
	//rc = o_prepare_connection(oh, ORIENT_PROTO_BINARY, "192.168.1.100", "2424");
	rc = o_prepare_connection(oh, ORIENT_PROTO_BINARY, "127.0.0.1", "2424");
	if (rc != O_OK) {
		o_strerr(rc, str, O_ERR_MAXLEN); 
		fprintf(stderr, "Error preparing connections (%i): %s\n", rc, str);
		o_free(oh);
		return rc;
	}
	
	// this user will be used to execute administrative commands to orientdb
	rc = o_prepare_user(oh, ORIENT_ADMIN, "root", "test");
	// this user will be used on database open to execute commands to the db
	rc = o_prepare_user(oh, ORIENT_USER, "admin", "admin");
	
	// set a connection timeout of 5 seconds
	tv.tv_sec = 5;
	tv.tv_usec = 0;
	// try to create the connection with orientdb. NULL if a problem is encountered 
	oc = o_connect(oh, &tv, 0);
	if (!oc) {
		o_free(oh);
		return 1;
	}
	
	// set a connection timeout of 5 seconds
	tv.tv_sec = 15;
	tv.tv_usec = 0;
	rc = o_bin_dbopen(oh, oc, &tv, 0, "test");
	
	tv.tv_sec = 15;
	tv.tv_usec = 0;
	
	// initialize a new document with the classname called "Class"
	ODOC_INITIALIZE_DOCUMENT(odoc, NULL);
	if (!odoc) {
		fprintf(stderr, "RECORD_CREATE: problem initializating document\n");
		tv.tv_sec = 5;
		tv.tv_usec = 0;
		rc = o_bin_dbclose(oh, oc, &tv, 0);
		o_close(oh, oc);
		o_free(oh);
		return 0;
	}
	odoc_setraw(odoc, "nully:,shorty:10s,inty:20,embeddeddocy:(stringyembeddy:\"Hello world!! This is a string\",intyembeddy:12345),binny:_SGVsbG8gd29ybGQhISBUaGlzIGlzIGEgc3RyaW5n_,collecty:[]", strlen("nully:,shorty:10s,inty:20,embeddeddocy:(stringyembeddy:\"Hello world!! This is a string\",intyembeddy:12345),binny:_SGVsbG8gd29ybGQhISBUaGlzIGlzIGEgc3RyaW5n_,collecty:[]"));
	
	tv.tv_sec = 3;
	tv.tv_usec = 0;
	position = o_bin_recordcreate(oh, oc, &tv, 0, 6, odoc, O_RECORD_DOC, O_RECSYNC);
	fprintf(stderr, "RECORD_CREATE: %ld\n", position);
	i = ODOC_FREE_DOCUMENT(odoc);
	
	tv.tv_sec = 10;
	tv.tv_usec = 0;
	rc = o_bin_dbclose(oh, oc, &tv, 0);
	
	o_close(oh, oc);
	o_free(oh);
	
	return 0;
}
void ComponentVisualizerNode::expand(VariableNode* a_pVariableNode, const vector<reflection::Expression*>& a_LeftExpressions) const 
{
    a_pVariableNode->setDelegate(o_new(ComponentVariableNodeDelegate));
    
}
Beispiel #20
0
InvalidExpression* InvalidExpression::clone() const
{
    return o_new(InvalidExpression)(m_pValueType);
}
UpdateComponentDataCommand* UpdateComponentDataCommand::clone() const
{
    return o_new(UpdateComponentDataCommand)(m_pDataBase, m_Guids);
}
serialization::Bundle* PolymorphicArrayClass::createBundle( serialization::BundleNode* a_pOwnerNode ) const
{
    return o_new(serialization::native::TBundle<util::PolymorphicArray>)(a_pOwnerNode);
}
Type* PolymorphicArrayClass::createConstType() const
{
    return o_new(native::TConstType<PolymorphicArrayClass>)(const_cast<PolymorphicArrayClass*>(this));
}
PropertyExpression* PropertyExpression::clone() const
{
    return o_new(PropertyExpression)(m_pLeftExpression, m_pProperty);
}
Beispiel #25
0
int main() {
	orientdb *oh;
	orientdb_con *oc;
	struct timeval tv;
	
	int rc;
	char str[O_ERR_MAXLEN];
	
	ODOC_OBJECT *odoc;
	
	short cluster_id;
	long cluster_position;
	
	// create the orientdb object
	oh = o_new();
	
	// setup debug hook, so that my_debug() finction will be invoked each time the library has to say something useful
	o_debug_setlevel(oh, ORIENT_DEBUG);
	o_debug_sethook(oh, &my_debug);
	
	// prepare the connection to the database (no real connection will be made)
	rc = o_prepare_connection(oh, ORIENT_PROTO_BINARY, "127.0.0.1", "2424");
	if (rc != O_OK) {
		o_strerr(rc, str, O_ERR_MAXLEN); 
		fprintf(stderr, "Error preparing connections (%i): %s\n", rc, str);
		o_free(oh);
		return rc;
	}
	
	// this user will be used to execute administrative commands to orientdb
	rc = o_prepare_user(oh, ORIENT_ADMIN, "root", "test");
	// this user will be used on database open to execute commands to the db
	rc = o_prepare_user(oh, ORIENT_USER, "admin", "admin");
	
	// set a connection timeout of 5 seconds
	tv.tv_sec = 5;
	tv.tv_usec = 0;
	// try to create the connection with orientdb. NULL if a problem is encountered 
	oc = o_connect(oh, &tv, 0);
	if (!oc) {
		o_free(oh);
		return 1;
	}
	
	// set a timeout of 10 seconds
	tv.tv_sec = 10;
	tv.tv_usec = 0;
	
	// Open a database named "test"
	rc = o_bin_dbopen(oh, oc, &tv, 0, "test");
	
	// set a timeout of 15 seconds
	tv.tv_sec = 15;
	tv.tv_usec = 0;
	
	// simulating a record id like #6:0
	cluster_id = 6;
	cluster_position = 0;
	
	// get the document from the database
	odoc = o_bin_recordload(oh, oc, &tv, 0, cluster_id, cluster_position, "*:-1");
	if (!odoc) {
		fprintf(stderr, "RECORD_LOAD: problem getting record\n");
		tv.tv_sec = 5;
		tv.tv_usec = 0;
		rc = o_bin_dbclose(oh, oc, &tv, 0);
		o_close(oh, oc);
		o_free(oh);
		return 0;
	}
	fprintf(stderr, "RECORD_LOAD: got a document: %s\n", odoc_getraw(odoc, NULL));
	
	// free the returned document when you no longer need it
	ODOC_FREE_DOCUMENT(odoc);
	
	tv.tv_sec = 5;
	tv.tv_usec = 0;
	rc = o_bin_dbclose(oh, oc, &tv, 0);
	
	o_close(oh, oc);
	o_free(oh);
	
	return 0;
}
Beispiel #26
0
UndoCommand* UndoCommand::clone() const
{
    return o_new(UndoCommand)(m_strName);
}
AggregationInsertRemoveExpression* AggregationInsertRemoveExpression::clone() const
{
    return o_new(AggregationInsertRemoveExpression)(m_pLeftExpression, m_pIndexExpression, m_pAggregationClass);
}
CompositionRemoveComponentDataCommand* CompositionRemoveComponentDataCommand::clone() const
{
    return o_new(CompositionRemoveComponentDataCommand)(m_pDataBase, m_uiIndex, m_uiOwnerGuid, m_strCompositionExpression);
}
AggregationGetSetExpression* AggregationGetSetExpression::clone() const
{
    return o_new(AggregationGetSetExpression)(m_pLeftExpression, m_pIndexExpression, m_pAggregationClass);
}
LocalVariableInitializationStatement* LocalVariableInitializationStatement::clone() const
{
    return o_new(LocalVariableInitializationStatement)(m_pLocalVariable, m_pRightExpression);
}